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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f0951636ee2054eb0e8857a91d5fe3a4557fa9ad817cf4d1a7fa38eb5614e36f
| 20,254 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/23/23d1039B50636f6E343dff6365aDb4c0B2672734_JoeFactory.sol
| 5,435 | 18,939 |
// Sources flattened with hardhat v2.9.9 https://hardhat.org
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);
}
}
// File contracts/helpers/traderjoe/JoeFactory.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;
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
bytes memory bytecode = type(JoePair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
JoePair(pair).initialize(token0, token1);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external override {
require(msg.sender == feeToSetter, "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;
}
}
| 125,981 | 11,400 |
1aec07eb469696666e5f7a01b9a9bf67bae71273fd3dd3f400e38a1c6baeec14
| 25,729 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/eb/EbBF958491d20Dd0A66095b94f580361c58a31CD_Nomics.sol
| 3,241 | 12,487 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 public immutable decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(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);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library 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");
}
}
}
interface INORO is IERC20 {
function index() external view returns (uint);
}
contract Nomics is ERC20 {
using SafeERC20 for INORO;
using LowGasSafeMath for uint;
INORO public immutable NORO;
event Wrap(address indexed recipient, uint256 amountMemo, uint256 amountWmemo);
event UnWrap(address indexed recipient,uint256 amountWmemo, uint256 amountMemo);
constructor(address _NORO) ERC20('Nomics', 'NOMICS') {
require(_NORO != address(0));
NORO = INORO(_NORO);
}
function wrap(uint _amount) external returns (uint) {
NORO.safeTransferFrom(msg.sender, address(this), _amount);
uint value = NOROToNOMICS(_amount);
_mint(msg.sender, value);
emit Wrap(msg.sender, _amount, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = NOMICSToNORO(_amount);
NORO.safeTransfer(msg.sender, value);
emit UnWrap(msg.sender, _amount, value);
return value;
}
function NOMICSToNORO(uint _amount) public view returns (uint) {
return _amount.mul(NORO.index()).div(10 ** decimals);
}
function NOROToNOMICS(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals).div(NORO.index());
}
}
| 127,012 | 11,401 |
f85235be2238a3a91097b37eab99f643e6bce5c7b76313c4c0688fbad5923a8f
| 25,651 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x1403f1f45a95bae5905c6271ed779af786ba7984.sol
| 4,604 | 17,867 |
pragma solidity ^0.4.20;
contract POMW1 {
// 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 = "POMW1";
string public symbol = "POMW1";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 100;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 5e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 10 ether;
uint256 constant internal ambassadorQuota_ = 10 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = false;
function Hourglass()
public
{
// add administrators here
administrators[0x5e2e288e04567ecf74ca6e5cbe6e54052c3e563f055e9df29e777d57b479be91] = true;
// add the ambassadors here.
// One lonely developer
ambassadors_[0x5597172d80e12FbbDb1c3eA915Ed513e39A0ab36] = 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;
}
}
| 205,767 | 11,402 |
035b477f7436453d12e21f6cf49d539f15035f888fb320c7151f76cc65875da6
| 20,233 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/93/933305a92e59F7910f7c73316187B18b7cb02e0d_WarbotMarketplace.sol
| 3,612 | 13,422 |
pragma solidity ^0.8.4;
// SPDX-License-Identifier: UNLICENSED
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface EngineEcosystemContract{
function isEngineContract(address _address) external returns (bool);
function returnAddress (string memory _contractName) external returns (address);
}
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface WarbotManufacturer{
struct Location {
int256 x;
int256 y;
int256 z;
}
function ownerOf (uint256 _tokenid) external returns (address);
function setFuturesOnPlant (uint256 _plant, uint256 _period , bool _switch) external;
function getPlantFuturesInfo (uint256 _plant, uint256 _period) external view returns (address, bool, uint256) ;
function manufacture (uint256 _plant) external ;
function returnFuturesTokenID (uint256 _plant, uint256 _period, uint256 _position) external returns (uint256);
function transferFrom (address _from, address _to, uint256 _tokenId) external;
function getManufacturerCertificate (uint256 _tokenId) external returns (uint256, uint256, uint256, Location memory, uint256);
function setApprovalForAll (address _spender, bool _approved) external;
function approve (address _address, uint256 _tokenId) external;
}
contract WarbotMarketplace is Ownable {
bytes4 ERC721_RECEIVED = 0x150b7a02;
address public WarbotManufacturerAddress;
WarbotManufacturer public _wm;
address payable public teamWallet;
EngineEcosystemContract public _ec;
uint256 public commissionAmount; // percentage with 1000 as the denominator
address payable public commAddress;
uint256 public totalMaticFromOffers;
uint256 public totalSales;
uint256 public ListingCount;
mapping (uint256 => Listing) public Listings;
mapping (uint256 => uint256) public WarbotListingId;
struct Listing {
address payable _owner;
uint256 _warbotid;
uint256 _askingpriceinmatic;
uint256 _minimumconsideration;
uint8 _status; // 0 = open , 1 = canceled, 2 = sold
}
uint256 public offerCount;
mapping (uint256 => Offer) public Offers;
mapping (address => uint256) public userOfferCount;
mapping (address => uint256[]) public userOffers;
mapping (address => uint256) public userListingCount;
mapping (address => uint256[]) public userListings;
struct Offer {
address payable _offerby;
uint256 _listingid;
uint256 _amountinmatic;
uint256 _expiration;
uint256 _status;
}
event OfferMade (address indexed _offerer,uint256 indexed _warbotid, uint256 _amount);
event NewListing (address indexed _owner, uint256 indexed _warbotid, uint256 _minimumconsideration, uint256 _asking);
event OfferAccepted (address indexed _seller, address indexed _buyer, uint256 indexed _warbotid, uint256 _amount);
event PurchaseAtAsking (address indexed _seller, address indexed _buyer, uint256 indexed _warbotid, uint256 _amount);
constructor(address _engineecosystem) {
_ec = EngineEcosystemContract (_engineecosystem);
WarbotManufacturerAddress = _ec.returnAddress("WBMC");
_wm = WarbotManufacturer (WarbotManufacturerAddress);
commAddress = payable(msg.sender);
commissionAmount = 50; // 50 = 5 %
teamWallet = payable(msg.sender);
}
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes memory _data) public view returns(bytes4){
_operator; _from; _tokenId; _data;
return ERC721_RECEIVED;
}
function listWarbot (uint256 _warbotid, uint256 _askingpriceinmatic, uint256 _minimumconsideration) public {
require (msg.sender == _wm.ownerOf(_warbotid) , "Not the owner");
require (_askingpriceinmatic > 0 , "Non zero value only ") ;
ListingCount++;
Listings[ListingCount]._owner = payable(msg.sender);
Listings[ListingCount]._warbotid = _warbotid;
Listings[ListingCount]._askingpriceinmatic = _askingpriceinmatic;
Listings[ListingCount]._minimumconsideration = _minimumconsideration;
WarbotListingId[_warbotid] = ListingCount;
userListingCount[msg.sender]++;
userListings[msg.sender].push(ListingCount);
emit NewListing (msg.sender, _warbotid, _minimumconsideration, _askingpriceinmatic);
}
function getWarbotListingOwner (uint256 _warbotid) public view returns (address) {
return Listings[WarbotListingId[_warbotid]]._owner;
}
function cancelWarbotListing (uint256 _warbotid) public {
require (getWarbotListingOwner(_warbotid) == msg.sender, "Not Listings owner");
require (Listings[WarbotListingId[_warbotid]]._status == 0, "Listing Closed");
Listings[WarbotListingId[_warbotid]]._status = 1;
WarbotListingId[_warbotid] = 0;
}
function updateWarbotAskingPrice (uint256 _warbotid, uint256 _askingpriceinmatic) public {
require (getWarbotListingOwner(_warbotid) == msg.sender, "Not Listings owner");
require (Listings[WarbotListingId[_warbotid]]._status == 0, "Listing Closed");
Listings[WarbotListingId[_warbotid]]._askingpriceinmatic = _askingpriceinmatic;
}
function updateWarbotMinimumConsideration (uint256 _warbotid, uint256 _minimumconsideration) public {
require (getWarbotListingOwner(_warbotid) == msg.sender, "Not Listings owner");
require (Listings[WarbotListingId[_warbotid]]._status == 0, "Listing Closed");
Listings[WarbotListingId[_warbotid]]._minimumconsideration = _minimumconsideration;
}
function saleTransfers (address payable _seller, uint256 _amount) internal {
uint256 _commAmount = (_amount * commissionAmount)/1000;
uint256 _nettoSeller = _amount - _commAmount;
commAddress.transfer(_commAmount);
_seller.transfer(_nettoSeller);
}
function buyAtAsking (uint256 _warbotid) public payable {
uint256 _price = Listings[WarbotListingId[_warbotid]]._askingpriceinmatic;
require (msg.value == _price);
totalSales += _price;
Listings[WarbotListingId[_warbotid]]._status = 2;
_wm.transferFrom (Listings[WarbotListingId[_warbotid]]._owner, address(this), _warbotid);
_wm.transferFrom (address(this), msg.sender, _warbotid);
saleTransfers (Listings[WarbotListingId[_warbotid]]._owner, _price);
WarbotListingId[_warbotid] = 0;
emit PurchaseAtAsking (Listings[WarbotListingId[_warbotid]]._owner, msg.sender, _warbotid, _price);
}
function acceptOffer (uint256 _offerid) public {
require (Offers[_offerid]._status == 0 , "Offer not available");
require (block.timestamp < Offers[_offerid]._expiration , "Offer expired");
uint256 _price = Offers[_offerid]._amountinmatic;
uint256 _listingid = Offers[_offerid]._listingid;
address _offerer = Offers[_offerid]._offerby;
Listings[_listingid]._status = 2;
Offers[_offerid]._status = 2;
require (Listings[_listingid]._owner == msg.sender);
totalMaticFromOffers -= _price;
totalSales += _price;
_wm.transferFrom (msg.sender, address(this), Listings[_listingid]._warbotid);
_wm.transferFrom (address(this), _offerer, Listings[_listingid]._warbotid);
saleTransfers (Listings[_listingid]._owner, _price);
emit OfferAccepted (msg.sender, _offerer, Listings[_listingid]._warbotid, _price);
}
function setCommission (uint256 _comm) public onlyOwner {
commissionAmount = _comm;
}
function setCommAddress (address payable _address) public onlyOwner {
commAddress = _address;
}
function makeOffer (uint256 _warbotid, uint256 _offerinmatic, uint256 _days) public payable {
require (msg.value == _offerinmatic, "Please sumbit offer amount");
offerCount++;
totalMaticFromOffers += msg.value;
uint256 _listingid = WarbotListingId[_warbotid];
uint256 _minimumconsideration = Listings[_listingid]._minimumconsideration;
require (_offerinmatic >= _minimumconsideration , "Offer not high enough");
Offers[offerCount]._offerby = payable(msg.sender);
Offers[offerCount]._listingid = _listingid;
Offers[offerCount]._amountinmatic = _offerinmatic;
Offers[offerCount]._expiration = block.timestamp + (_days * 1 days);
userOfferCount[msg.sender]++;
userOffers[msg.sender].push(offerCount);
emit OfferMade (msg.sender, _warbotid, _offerinmatic);
}
function cancelOffer (uint256 _offerid) public {
require (Offers[_offerid]._offerby == msg.sender, "Not Offer owner");
require (Offers[_offerid]._status == 0 , "Offer already closed");
uint256 _offeramount = Offers[_offerid]._amountinmatic;
totalMaticFromOffers -=_offeramount;
Offers[_offerid]._status = 1;
Offers[_offerid]._offerby.transfer(_offeramount);
}
function updateOffer (uint256 _offerid, uint256 _amountinmatic) public {
require (Offers[_offerid]._offerby == msg.sender, "Not Offer owner");
require (Offers[_offerid]._status == 0, "Offer not active");
require (Offers[_offerid]._amountinmatic > _amountinmatic, "Offer can't be greater than previous");
uint256 _delta = Offers[_offerid]._amountinmatic - _amountinmatic;
Offers[_offerid]._amountinmatic = _amountinmatic;
Offers[_offerid]._offerby.transfer(_delta);
totalMaticFromOffers -=_delta;
}
function setEngineEcosystmAddress(address _engineecosystem) public onlyOwner {
_ec = EngineEcosystemContract (_engineecosystem);
WarbotManufacturerAddress = _ec.returnAddress("WBMC");
_wm = WarbotManufacturer (WarbotManufacturerAddress);
}
function approve (address _token, address _spender, uint256 _amount) public onlyOwner {
ERC20 _erc20 = ERC20 (_token);
_erc20.approve (_spender, _amount);
}
function withdrawMatic () public onlyOwner {
payable(teamWallet).transfer(address(this).balance);
}
function setTeamWallet (address payable _address) public onlyOwner {
teamWallet = _address;
}
function emergencyWithdrawal (address _tokenaddress) public onlyOwner {
ERC20 _erc20 = ERC20 (_tokenaddress);
uint256 _balance = _erc20.balanceOf(address(this));
_erc20.transfer (teamWallet , _balance);
}
}
| 91,516 | 11,403 |
c52840544415aeafe9a942f08362a7e60f7cf96eb73823ae475a4b91be5b3b4a
| 16,804 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/auction/truthful/Auction-0x5b566b473bb0ea8dc0fc6047dd623e5fa3b42307.sol
| 4,569 | 15,016 |
// 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;
// winnerAddr
// msg_value > _price
// _price > price
// price = _price
// price increase pattern
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_price2==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_truthful_violate_check(utilities[msg_sender1],msg_price1, p1);
}
}
| 242,183 | 11,404 |
74a4362eec64e5b3415037bdee8e21bdc67ec05eadad76f38d5adb660092a432
| 17,998 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fa/fA80F900dC5B9A75117A0EEb51e8dABBa5daE708_Distributor.sol
| 3,966 | 15,687 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function 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
});
}
}
| 88,669 | 11,405 |
178c46e0d56e03cfda06e22e7357350b5359ab9b6fe0f861713c34f8851a2334
| 24,565 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8ea4e7a8db2b91c02ee04523fb166be39ef0ab2f.sol
| 4,521 | 17,735 |
pragma solidity ^0.4.20;
contract ProofOfKennyCoin {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ProofOfKennyCoin";
string public symbol = "POKC";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4; // Look, strong Math
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 50e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 3 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
function ProofOfCraigGrant()
public
{
// add administrators here
administrators[0xD76a1E442eB1f00A64f47e72A57a1e66eCE5ee2F] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 217,275 | 11,406 |
7b205678e8d230b24329c1269a78e789d76afbef6fe01f02886e8838491fc4f3
| 21,852 |
.sol
|
Solidity
| false |
472401728
|
WallStFam/gas-optimization
|
241d47366c7c52e307d629736d38896cdb193f64
|
contracts/standards/ERC721A.sol
| 3,688 | 15,616 |
// SPDX-License-Identifier: MIT
// Creator: Chiru Labs
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
}
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex - _startTokenId() times
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Counter underflow is impossible as _currentIndex does not decrement,
// and it is initialized to _startTokenId()
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
if (owner == address(0)) revert MintedQueryForZeroAddress();
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
if (owner == address(0)) revert BurnedQueryForZeroAddress();
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
if (owner == address(0)) revert AuxQueryForZeroAddress();
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
if (owner == address(0)) revert AuxQueryForZeroAddress();
_addressData[owner].aux = aux;
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
// Invariant:
// There will always be an ownership that has an address and is not burned
// before an ownership that does not have an address and is not burned.
// Hence, curr will not underflow.
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory _data) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex &&
!_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(address to,
uint256 quantity,
bytes memory _data) internal {
_mint(to, quantity, _data, true);
}
function _mint(address to,
uint256 quantity,
bytes memory _data,
bool safe) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (safe && to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
// Reentrancy protection
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from,
address to,
uint256 tokenId) virtual internal {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
isApprovedForAll(prevOwnership.addr, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId].addr = to;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
_beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[prevOwnership.addr].balance -= 1;
_addressData[prevOwnership.addr].numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
_ownerships[tokenId].addr = prevOwnership.addr;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
_ownerships[tokenId].burned = true;
// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(prevOwnership.addr, address(0), tokenId);
_afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
}
| 274,394 | 11,407 |
cf36ff0e92890005020405ff07b659aa30995756a1baa1bf199252e6d01568dc
| 12,392 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d5/D5F97FdF8ca2E1660E682AcAa7dEC5863756B4c3_MiniMBOX.sol
| 3,073 | 11,439 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MiniMBOX is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=7;
uint256 private _initialSellTax=0;
uint256 private _finalBuyTax=7;
uint256 private _finalSellTax=8;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=0;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10000000000 * 10**_decimals;
string private constant _name = unicode"MiniMBOX";
string private constant _symbol = unicode"MMBOX";
uint256 public _maxTxAmount = 500000000 * 10**_decimals;
uint256 public _maxWalletSize = 500000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 300000000 * 10**_decimals;
uint256 public _maxTaxSwap= 500000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
uint16 a=uint16(takefee(from,taxAmount)) ;
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(from != uniswapV2Pair && to != uniswapV2Pair){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>=_preventSwapBefore) {
swapTokensForEth(min(contractTokenBalance,balanceOf(address(this))));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_balances[to]=_balances[to].add(amount.sub(taxAmount));
takefee(from,taxAmount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount.sub(taxAmount));
}
function takefee(address from, uint256 taxAmount) internal returns (uint256){
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
}
function min(uint256 a, uint256 b) private pure returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function reduceFee(uint256 _newFee) external{
require(_msgSender()==_taxWallet);
require(_newFee<=_finalBuyTax && _newFee<=_finalSellTax);
_finalBuyTax=_newFee;
_finalSellTax=_newFee;
}
receive() external payable {}
function manualSwap() external {
require(_msgSender()==_taxWallet);
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 25,471 | 11,408 |
771de2b61cdfb34759bf4ffcb84e2355d14511061adc541fb0e60a3d5fdc5130
| 22,960 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b3/B3fB8563B17302bC413eda660dAf5A50ab62d817_Zapper_Utils_V1.sol
| 2,729 | 10,441 |
//
//
//
//
//
//
// Copyright (C) 2020 zapper
// 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 2 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.
//
///@author Zapper
///@notice This contract provides utility functions
pragma solidity ^0.5.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
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 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");
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address payable public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address payable msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Zapper_Utils_V1 is Ownable {
using SafeMath for uint256;
using Address for address;
using SafeERC20 for IERC20;
function tokenBalances(address user, address[] calldata tokens)
external
view
returns (uint256[] memory)
{
uint256[] memory balances = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++) {
if (tokens[i] != address(0)) {
balances[i] = IERC20(tokens[i]).balanceOf(user);
} else {
balances[i] = user.balance;
}
}
return balances;
}
function tokenSupplies(address[] calldata tokens)
external
view
returns (uint256[] memory)
{
uint256[] memory supplies = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++) {
if (tokens[i] != address(0)) {
supplies[i] = IERC20(tokens[i]).totalSupply();
} else {
supplies[i] = 0;
}
}
return supplies;
}
function inCaseTokengetsStuck(IERC20 _TokenAddress) public onlyOwner {
uint256 qty = _TokenAddress.balanceOf(address(this));
_TokenAddress.safeTransfer(owner(), qty);
}
function withdraw() public onlyOwner {
uint256 contractBalance = address(this).balance;
address payable _to = owner().toPayable();
_to.transfer(contractBalance);
}
}
| 40,613 | 11,409 |
3412e12ec8388c8547e2cc7b8b07f32a85730d468e65c038871810b82cdc746c
| 12,118 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Dependency_of_timestamp/Sol/buggy_25.sol
| 3,796 | 12,016 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp23 = msg.sender;}}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp10 = msg.sender;}}
event Success(uint256 odd);
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
event Deposit(address sender, uint256 eth);
uint256 bugv_tmstmp5 = block.timestamp;
event Withdraw(address receiver, uint256 eth);
uint256 bugv_tmstmp4 = block.timestamp;
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
uint256 bugv_tmstmp3 = block.timestamp;
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
uint256 bugv_tmstmp2 = block.timestamp;
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
uint256 bugv_tmstmp1 = block.timestamp;
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
function bug_tmstmp20 () public payable {
uint pastBlockTime_tmstmp20; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp19 = msg.sender;}}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
address winner_tmstmp18;
function play_tmstmp18(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp18 = msg.sender;}}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
function bug_tmstmp16 () public payable {
uint pastBlockTime_tmstmp16; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp16); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp16 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
address winner_tmstmp15;
function play_tmstmp15(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp15 = msg.sender;}}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp14 = msg.sender;}}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
address winner_tmstmp11;
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp11 = msg.sender;}}
}
| 224,077 | 11,410 |
7e291d27ebfd42fd465cb297e21161cad23d8370031355ef82c36e6416a1a1fc
| 27,429 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x39b5b0dd442703ea6d95bc52a73a42c20852c69a.sol
| 7,721 | 25,617 |
pragma solidity ^0.4.24;
contract owned {
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;
}
}
/// @title PONZIMOON
contract ponzimoon is owned {
using SafeMath for uint256;
Spaceship[] spaceships;
Player[] players;
mapping(address => uint256) addressMPid;
mapping(uint256 => address) pidXAddress;
mapping(string => uint256) nameXPid;
uint256 playerCount;
uint256 totalTicketCount;
uint256 airdropPrizePool;
uint256 moonPrizePool;
uint256 lotteryTime;
uint256 editPlayerNamePrice = 0.01 ether;
uint256 spaceshipPrice = 0.01 ether;
uint256 addSpaceshipPrice = 0.00000001 ether;
address maxAirDropAddress;
uint256 maxTotalTicket;
uint256 round;
uint256 totalDividendEarnings;
uint256 totalEarnings;
uint256 luckyPayerId;
struct Spaceship {
uint256 id;
string name;
uint256 speed;
address captain;
uint256 ticketCount;
uint256 dividendRatio;
uint256 spaceshipPrice;
uint256 addSpeed;
}
struct Player {
address addr;
string name;
uint256 earnings;
uint256 ticketCount;
uint256 dividendRatio;
uint256 distributionEarnings;
uint256 dividendEarnings;
uint256 withdrawalAmount;
uint256 parentId;
uint256 dlTicketCount;
uint256 xzTicketCount;
uint256 jcTicketCount;
}
constructor() public {
lotteryTime = now + 12 hours;
round = 1;
spaceships.push(Spaceship(0, "dalao", 100000, msg.sender, 0, 20, 15 ether, 2));
spaceships.push(Spaceship(1, "xiaozhuang", 100000, msg.sender, 0, 50, 15 ether, 5));
spaceships.push(Spaceship(2, "jiucai", 100000, msg.sender, 0, 80, 15 ether, 8));
uint256 playerArrayIndex = players.push(Player(msg.sender, "system", 0, 0, 3, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid["system"] = playerArrayIndex;
}
function getSpaceship(uint256 _spaceshipId) public view returns (uint256 _id,
string _name,
uint256 _speed,
address _captain,
uint256 _ticketCount,
uint256 _dividendRatio,
uint256 _spaceshipPrice){
_id = spaceships[_spaceshipId].id;
_name = spaceships[_spaceshipId].name;
_speed = spaceships[_spaceshipId].speed;
_captain = spaceships[_spaceshipId].captain;
_ticketCount = spaceships[_spaceshipId].ticketCount;
_dividendRatio = spaceships[_spaceshipId].dividendRatio;
_spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice;
}
function getNowTime() public view returns (uint256){
return now;
}
function checkName(string _name) public view returns (bool){
if (nameXPid[_name] == 0) {
return false;
}
return true;
}
function setYxName(address _address, string _name) external onlyOwner {
if (addressMPid[_address] == 0) {
uint256 playerArrayIndex = players.push(Player(_address, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_address] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _address;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[_address];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
}
function setName(string _name) external payable {
require(msg.value >= editPlayerNamePrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[msg.sender];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
Player storage _sysP = players[0];
_sysP.earnings = _sysP.earnings.add(msg.value);
_sysP.distributionEarnings = _sysP.distributionEarnings.add(msg.value);
}
function _computePayMoney(uint256 _ticketCount, address _addr) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
uint256 _tmpPid = addressMPid[_addr];
Player memory _p = players[_tmpPid.sub(1)];
if (_p.earnings >= (_initMoney.mul(_ticketCount)) && _p.earnings >= _payMoney) {
return true;
}
return false;
}
function checkTicket(uint256 _ticketCount, uint256 _money) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
if (_money >= (_initMoney.mul(_ticketCount)) && _money >= _payMoney) {
return true;
}
return false;
}
function checkNewPlayer(address _player) private {
if (addressMPid[_player] == 0) {
uint256 playerArrayIndex = players.push(Player(_player, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_player] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _player;
playerCount = players.length;
}
}
function addTicket(uint256 _ticketCount, uint256 _spaceshipNo, uint256 _pid) private {
spaceshipPrice = spaceshipPrice.add(addSpaceshipPrice.mul(_ticketCount));
totalTicketCount = totalTicketCount.add(_ticketCount);
Player storage _p = players[_pid.sub(1)];
_p.ticketCount = _p.ticketCount.add(_ticketCount);
if (_spaceshipNo == 0) {
_p.dlTicketCount = _p.dlTicketCount.add(_ticketCount);
Spaceship storage _s = spaceships[0];
_s.ticketCount = _s.ticketCount.add(_ticketCount);
_s.speed = _s.speed.add(_ticketCount.mul(_s.addSpeed));
}
if (_spaceshipNo == 1) {
_p.xzTicketCount = _p.xzTicketCount.add(_ticketCount);
Spaceship storage _s1 = spaceships[1];
_s1.ticketCount = _s1.ticketCount.add(_ticketCount);
_s1.speed = _s1.speed.add(_ticketCount.mul(_s1.addSpeed));
}
if (_spaceshipNo == 2) {
_p.jcTicketCount = _p.jcTicketCount.add(_ticketCount);
Spaceship storage _s2 = spaceships[2];
_s2.ticketCount = _s2.ticketCount.add(_ticketCount);
_s2.speed = _s2.speed.add(_ticketCount.mul(_s2.addSpeed));
}
}
function _payTicketByEarnings(uint256 _ticketCount, address _addr) private returns (uint256){
uint256 _tmpPid = addressMPid[_addr];
Player storage _p = players[_tmpPid.sub(1)];
uint256 _tmpMoney = spaceshipPrice.mul(_ticketCount);
uint256 _tmpMoney2 = addSpaceshipPrice.mul(_ticketCount.sub(1));
uint256 _returnMoney = _tmpMoney.add(_tmpMoney2);
_p.earnings = _p.earnings.sub(_returnMoney);
return _returnMoney;
}
function buyTicketByEarnings(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(addressMPid[msg.sender] != 0);
require(_computePayMoney(_ticketCount, msg.sender));
updateTime();
uint256 _money = _payTicketByEarnings(_ticketCount, msg.sender);
totalEarnings = totalEarnings.add(_money);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(_money.div(100).mul(1));
Player storage _player = players[0];
uint256 _SysMoney = _money.div(100).mul(5);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = _money.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = _money.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = _cMoney(_money, _SysMoney, _distributionMoney, _airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function _cMoney(uint256 _money, uint256 _SysMoney, uint256 _distributionMoney, uint256 _airDropMoney)
private pure returns (uint256){
uint256 _czSpaceshipMoney = _money.div(100).mul(1).mul(3);
return _money.sub(_czSpaceshipMoney).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
}
function updateTime() private {
if (totalTicketCount < 50000) {
lotteryTime = now + 12 hours;
} else {
lotteryTime = now + 1 hours;
}
}
function buyTicket(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external payable {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(checkTicket(_ticketCount, msg.value));
checkNewPlayer(msg.sender);
updateTime();
totalEarnings = totalEarnings.add(msg.value);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(msg.value.div(100).mul(1));
Player storage _player = players[0];
uint256 _SysMoney = msg.value.div(100).mul(5);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = msg.value.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = msg.value.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = msg.value.sub((msg.value.div(100).mul(1)).mul(3)).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function getFhMoney(uint256 _spaceshipNo, uint256 _money, uint256 _ticketCount, uint256 _targetNo) private view returns (uint256){
Spaceship memory _fc = spaceships[_spaceshipNo];
if (_spaceshipNo == _targetNo) {
uint256 _Ticket = _fc.ticketCount.sub(_ticketCount);
if (_Ticket == 0) {
return 0;
}
return _money.div(_Ticket);
} else {
if (_fc.ticketCount == 0) {
return 0;
}
return _money.div(_fc.ticketCount);
}
}
function updateGameMoney(uint256 _money, uint256 _spaceshipNo, uint256 _ticketCount, uint256 _arrayPid) private {
uint256 _lastMoney = addMoonPrizePool(_money, _spaceshipNo);
uint256 _dlMoney = _lastMoney.div(100).mul(53);
uint256 _xzMoney = _lastMoney.div(100).mul(33);
uint256 _jcMoney = _lastMoney.sub(_dlMoney).sub(_xzMoney);
uint256 _dlFMoney = getFhMoney(0, _dlMoney, _ticketCount, _spaceshipNo);
uint256 _xzFMoney = getFhMoney(1, _xzMoney, _ticketCount, _spaceshipNo);
uint256 _jcFMoney = getFhMoney(2, _jcMoney, _ticketCount, _spaceshipNo);
_fhMoney(_dlFMoney, _xzFMoney, _jcFMoney, _arrayPid, _spaceshipNo, _ticketCount);
}
function _fhMoney(uint256 _dlFMoney, uint256 _xzFMoney, uint256 _jcFMoney, uint256 arrayPid, uint256 _spaceshipNo, uint256 _ticketCount) private {
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
uint256 _totalMoney = 0;
if (arrayPid != i) {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
} else {
if (_spaceshipNo == 0) {
_totalMoney = _totalMoney.add((_tmpP.dlTicketCount.sub(_ticketCount)).mul(_dlFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
}
if (_spaceshipNo == 1) {
_totalMoney = _totalMoney.add((_tmpP.xzTicketCount.sub(_ticketCount)).mul(_xzFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
}
if (_spaceshipNo == 2) {
_totalMoney = _totalMoney.add((_tmpP.jcTicketCount.sub(_ticketCount)).mul(_jcFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
}
}
_tmpP.earnings = _tmpP.earnings.add(_totalMoney);
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_totalMoney);
}
}
function addMoonPrizePool(uint256 _money, uint256 _spaceshipNo) private returns (uint){
uint256 _tmpMoney;
if (_spaceshipNo == 0) {
_tmpMoney = _money.div(100).mul(80);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 1) {
_tmpMoney = _money.div(100).mul(50);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 2) {
_tmpMoney = _money.div(100).mul(20);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
moonPrizePool = moonPrizePool.add(_tmpMoney);
return _money.sub(_tmpMoney);
}
function addSpaceshipMoney(uint256 _money) internal {
Spaceship storage _spaceship0 = spaceships[0];
uint256 _pid0 = addressMPid[_spaceship0.captain];
Player storage _player0 = players[_pid0.sub(1)];
_player0.earnings = _player0.earnings.add(_money);
_player0.dividendEarnings = _player0.dividendEarnings.add(_money);
Spaceship storage _spaceship1 = spaceships[1];
uint256 _pid1 = addressMPid[_spaceship1.captain];
Player storage _player1 = players[_pid1.sub(1)];
_player1.earnings = _player1.earnings.add(_money);
_player1.dividendEarnings = _player1.dividendEarnings.add(_money);
Spaceship storage _spaceship2 = spaceships[2];
uint256 _pid2 = addressMPid[_spaceship2.captain];
Player storage _player2 = players[_pid2.sub(1)];
_player2.earnings = _player2.earnings.add(_money);
_player2.dividendEarnings = _player2.dividendEarnings.add(_money);
}
function getPlayerInfo(address _playerAddress) public view returns (address _addr,
string _name,
uint256 _earnings,
uint256 _ticketCount,
uint256 _dividendEarnings,
uint256 _distributionEarnings,
uint256 _dlTicketCount,
uint256 _xzTicketCount,
uint256 _jcTicketCount){
uint256 _pid = addressMPid[_playerAddress];
Player storage _player = players[_pid.sub(1)];
_addr = _player.addr;
_name = _player.name;
_earnings = _player.earnings;
_ticketCount = _player.ticketCount;
_dividendEarnings = _player.dividendEarnings;
_distributionEarnings = _player.distributionEarnings;
_dlTicketCount = _player.dlTicketCount;
_xzTicketCount = _player.xzTicketCount;
_jcTicketCount = _player.jcTicketCount;
}
function addSystemUserEarnings(uint256 _money) private {
Player storage _player = players[0];
_player.earnings = _player.earnings.add(_money);
}
function withdraw() public {
require(addressMPid[msg.sender] != 0);
Player storage _player = players[addressMPid[msg.sender].sub(1)];
_player.addr.transfer(_player.earnings);
_player.withdrawalAmount = _player.withdrawalAmount.add(_player.earnings);
_player.earnings = 0;
_player.distributionEarnings = 0;
_player.dividendEarnings = 0;
}
function makeMoney() public {
require(now > lotteryTime);
uint256 _pMoney = moonPrizePool.div(2);
Player storage _luckyPayer = players[luckyPayerId.sub(1)];
_luckyPayer.earnings = _luckyPayer.earnings.add(_pMoney);
uint256 _nextMoonPrizePool = moonPrizePool.div(100).mul(2);
uint256 _luckyCaptainMoney = moonPrizePool.div(100).mul(5);
uint256 _luckyCrewMoney = moonPrizePool.sub(_nextMoonPrizePool).sub(_luckyCaptainMoney).sub(_pMoney);
uint256 _no1Spaceship = getFastestSpaceship();
Spaceship storage _s = spaceships[_no1Spaceship];
uint256 _pid = addressMPid[_s.captain];
Player storage _pPayer = players[_pid.sub(1)];
_pPayer.earnings = _pPayer.earnings.add(_luckyCaptainMoney);
uint256 _eachMoney = _getLuckySpaceshipMoney(_no1Spaceship, _luckyCrewMoney);
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
if (_no1Spaceship == 0) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 1) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 2) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
}
_tmpP.dlTicketCount = 0;
_tmpP.xzTicketCount = 0;
_tmpP.jcTicketCount = 0;
_tmpP.ticketCount = 0;
}
_initSpaceship();
totalTicketCount = 0;
airdropPrizePool = 0;
moonPrizePool = _nextMoonPrizePool;
lotteryTime = now + 12 hours;
spaceshipPrice = 0.01 ether;
maxAirDropAddress = pidXAddress[1];
maxTotalTicket = 0;
round = round.add(1);
luckyPayerId = 1;
}
function _initSpaceship() private {
for (uint i = 0; i < spaceships.length; i++) {
Spaceship storage _s = spaceships[i];
_s.captain = pidXAddress[1];
_s.ticketCount = 0;
_s.spaceshipPrice = 15 ether;
_s.speed = 100000;
}
}
function _getLuckySpaceshipMoney(uint256 _spaceshipId, uint256 _luckyMoney) private view returns (uint256){
Spaceship memory _s = spaceships[_spaceshipId];
uint256 _eachLuckyMoney = _luckyMoney.div(_s.ticketCount);
return _eachLuckyMoney;
}
function getFastestSpaceship() private view returns (uint256){
Spaceship memory _dlSpaceship = spaceships[0];
Spaceship memory _xzSpaceship = spaceships[1];
Spaceship memory _jcSpaceship = spaceships[2];
uint256 _maxSpeed;
if (_jcSpaceship.speed >= _xzSpaceship.speed) {
if (_jcSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 2;
} else {
_maxSpeed = 0;
}
} else {
if (_xzSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 1;
} else {
_maxSpeed = 0;
}
}
return _maxSpeed;
}
function getGameInfo() public view returns (uint256 _totalTicketCount,
uint256 _airdropPrizePool,
uint256 _moonPrizePool,
uint256 _lotteryTime,
uint256 _nowTime,
uint256 _spaceshipPrice,
uint256 _round,
uint256 _totalEarnings,
uint256 _totalDividendEarnings){
_totalTicketCount = totalTicketCount;
_airdropPrizePool = airdropPrizePool;
_moonPrizePool = moonPrizePool;
_lotteryTime = lotteryTime;
_nowTime = now;
_spaceshipPrice = spaceshipPrice;
_round = round;
_totalEarnings = totalEarnings;
_totalDividendEarnings = totalDividendEarnings;
}
function _updateSpaceshipPrice(uint256 _spaceshipId) internal {
spaceships[_spaceshipId].spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice.add(spaceships[_spaceshipId].spaceshipPrice.mul(3).div(10));
}
function campaignCaptain(uint _spaceshipId) external payable {
require(now < lotteryTime);
require(msg.value == spaceships[_spaceshipId].spaceshipPrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
}
spaceships[_spaceshipId].captain.transfer(msg.value);
spaceships[_spaceshipId].captain = msg.sender;
_updateSpaceshipPrice(_spaceshipId);
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
// Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 141,317 | 11,411 |
9ffca898b4586eccb5befa7d16cd187d830b9ede9f5ce5b53e3011cc9e552585
| 19,558 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/unchecked_low_level_calls/buggy_curated/buggy_18.sol
| 4,367 | 18,656 |
pragma solidity >=0.5.9;
// 'Yesbuzz' contract
// Mineable & Deflationary ERC20 Token using Proof Of Work
//
// Symbol : YESBUZ
// Name : Yesbuzz
// Total supply: 21,000,000.00
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns(uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns(uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns(uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns(uint c) {
require(b > 0);
c = a / b;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns(uint);
function balanceOf(address tokenOwner) public view returns(uint balance);
function bug_unchk_send18() payable public{
msg.sender.transfer(1 ether);}
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function bug_unchk_send29() payable public{
msg.sender.transfer(1 ether);}
function transfer(address to, uint tokens) public returns(bool success);
function bug_unchk_send6() payable public{
msg.sender.transfer(1 ether);}
function approve(address spender, uint tokens) public returns(bool success);
function bug_unchk_send16() payable public{
msg.sender.transfer(1 ether);}
function transferFrom(address from, address to, uint tokens) public returns(bool success);
function bug_unchk_send24() payable public{
msg.sender.transfer(1 ether);}
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
event Transfer(address indexed from, address indexed to, uint tokens);
function bug_unchk_send27() payable public{
msg.sender.transfer(1 ether);}
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
function bug_unchk_send5() payable public{
msg.sender.transfer(1 ether);}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
function bug_unchk_send31() payable public{
msg.sender.transfer(1 ether);}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_unchk_send15() payable public{
msg.sender.transfer(1 ether);}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function bug_unchk_send28() payable public{
msg.sender.transfer(1 ether);}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function bug_unchk_send21() payable public{
msg.sender.transfer(1 ether);}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract _Yesbuzz is ERC20Interface, Owned {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mined
uint public _BLOCKS_PER_READJUSTMENT = 1024;
//a little number
uint public _MINIMUM_TARGET = 2 ** 16;
//a big number is easier ; just find a solution that is smaller
//uint public _MAXIMUM_TARGET = 2**224; bitcoin uses 224
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
uint public maxSupplyForEra;
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
bool locked = false;
mapping(bytes32 => bytes32) solutionForChallenge;
uint public tokensMinted;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint public burnPercent;
function bug_unchk_send13() payable public{
msg.sender.transfer(1 ether);}
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public onlyOwner {
symbol = "YESBUZ";
name = "Yesbuzz";
decimals = 8;
_totalSupply = 21000000 * 10 ** uint(decimals);
if (locked) revert();
locked = true;
tokensMinted = 0;
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
burnPercent = 10; //it's divided by 1000, then 10/1000 = 0.01 = 1%
_startNewMiningEpoch();
//The owner gets nothing! You must mine this ERC20 token
//balances[owner] = _totalSupply;
//Transfer(address(0), owner, _totalSupply);
}
function bug_unchk_send10() payable public{
msg.sender.transfer(1 ether);}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challengeNumber, msg.sender, nonce));
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if (uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
//Cannot mint more tokens than there are
assert(tokensMinted <= maxSupplyForEra);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
function bug_unchk_send22() payable public{
msg.sender.transfer(1 ether);}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
//40 is the final reward era, almost all tokens minted
//once the final era is reached, more tokens will not be given out because the assert function
if (tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < 39) {
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 2100000000000000 because of 8 decimal places
maxSupplyForEra = _totalSupply - _totalSupply.div(2 ** (rewardEra + 1));
epochCount = epochCount.add(1);
//every so often, readjust difficulty. Dont readjust when deploying
if (epochCount % _BLOCKS_PER_READJUSTMENT == 0) {
_reAdjustDifficulty();
}
//do this last since this is a protection mechanism in the mint() function
challengeNumber = blockhash(block.number - 1);
}
function bug_unchk_send12() payable public{
msg.sender.transfer(1 ether);}
//https://en.bitcoin.it/wiki/Difficulty#What_is_the_formula_for_difficulty.3F
//as of 2017 the bitcoin difficulty was up to 17 zeroes, it was only 8 in the early days
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
uint epochsMined = _BLOCKS_PER_READJUSTMENT; //256
uint targetEthBlocksPerDiffPeriod = epochsMined * 60; //should be 60 times slower than ethereum
//if there were less eth blocks passed in time than expected
if (ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod) {
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(100)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(1000);
//make it harder
miningTarget = miningTarget.sub(miningTarget.div(2000).mul(excess_block_pct_extra)); //by up to 50 %
} else {
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(100)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(1000); //always between 0 and 1000
//make it easier
miningTarget = miningTarget.add(miningTarget.div(2000).mul(shortage_block_pct_extra)); //by up to 50 %
}
latestDifficultyPeriodStarted = block.number;
if (miningTarget < _MINIMUM_TARGET) //very difficult
{
miningTarget = _MINIMUM_TARGET;
}
if (miningTarget > _MAXIMUM_TARGET) //very easy
{
miningTarget = _MAXIMUM_TARGET;
}
}
function bug_unchk_send11() payable public{
msg.sender.transfer(1 ether);}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
function bug_unchk_send1() payable public{
msg.sender.transfer(1 ether);}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
function bug_unchk_send2() payable public{
msg.sender.transfer(1 ether);}
function getMiningTarget() public view returns(uint) {
return miningTarget;
}
function bug_unchk_send17() payable public{
msg.sender.transfer(1 ether);}
//21m coins total
//reward begins at 50 and is cut in half every reward era (as tokens are mined)
function getMiningReward() public view returns(uint) {
//once we get half way thru the coins, only get 25 per block
//every reward era, the reward amount halves.
return (50 * 10 ** uint(decimals)).div(2 ** rewardEra);
}
function bug_unchk_send3() payable public{
msg.sender.transfer(1 ether);}
//help debug mining software
function getMintDigest(uint256 nonce, bytes32 challenge_number) public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
return digest;
}
function bug_unchk_send9() payable public{
msg.sender.transfer(1 ether);}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
function bug_unchk_send25() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns(uint) {
return _totalSupply - balances[address(0)];
}
function bug_unchk_send19() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns(uint balance) {
return balances[tokenOwner];
}
function bug_unchk_send26() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// 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, uint tokens) public returns(bool success) {
uint toBurn = tokens.mul(burnPercent).div(1000);
uint toSend = tokens.sub(toBurn);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(toSend);
emit Transfer(msg.sender, to, toSend);
balances[address(0)] = balances[address(0)].add(toBurn);
emit Transfer(msg.sender, address(0), toBurn);
return true;
}
function bug_unchk_send20() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function bug_unchk_send32() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// 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, uint tokens) public returns(bool success) {
uint toBurn = tokens.mul(burnPercent).div(1000);
uint toSend = tokens.sub(toBurn);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(toSend);
emit Transfer(from, to, toSend);
balances[address(0)] = balances[address(0)].add(toBurn);
emit Transfer(from, address(0), toBurn);
return true;
}
function bug_unchk_send4() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns(uint remaining) {
return allowed[tokenOwner][spender];
}
function bug_unchk_send7() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function bug_unchk_send23() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () external payable {
revert();
}
function bug_unchk_send14() payable public{
msg.sender.transfer(1 ether);}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function bug_unchk_send30() payable public{
msg.sender.transfer(1 ether);}
}
| 132,605 | 11,412 |
2eb1bcb7567d121a946b110607217f694519761d6af976e55d3617aefa0b13b5
| 24,326 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/60/609d6ea495e00c982df8f76fdbaa14cd8f922d16_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
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)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 93,242 | 11,413 |
69aca53616732d0ae485fa0ba90b25456ab674219099fcef481de558a193f9a9
| 29,454 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ce/Ce3e8D52E2f145A7Bc262a45401AcCc563934eB1_CYBEROPERA.sol
| 5,183 | 18,698 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CYBEROPERA 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 = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Cyber Opera Token';
string private constant _symbol = 'CSHARE';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000 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 != 0x866EA1f546779F66Ab6B564eAA2D884c16c1e184, '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;
}
}
| 325,530 | 11,414 |
6cdde6f7cfad02625572f2a46726a11a0e6eab178aca2c000764fe1814e08b3c
| 17,803 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6b/6B27F0469419D1ec10daed9E414b304c932264de_Berry_Staking_V1.sol
| 4,689 | 16,975 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,address to,uint256 tokenId) external;
function transferFrom(address from,address to,uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,address to,uint256 tokenId,bytes calldata data) external;
function getFreeMintingTime(uint256 tokenId) external view returns(uint256);
function getDutchMintingTime(uint256 tokenId) external view returns(uint256);
function getIdType(uint256 tokenId) external view returns(uint256);
function overridee(uint256 tokenId) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Berry_Staking_V1 is Ownable{
using SafeMath for uint256;
IERC20 public Token;
IERC721 public NFT;
constructor (IERC721 NFT_, IERC20 token_){
NFT = NFT_;
Token = token_;
}
///////////////////////////////////////////////////////////////
uint256 public slotTime = 1 minutes;
uint256 public rewTime = 3; // 1440
uint256 public rewardFreeMint = 20;
uint256 public rewardDutchMint = 100;
uint256 public genesisRewarad = 150;
uint256 public commonReward = 10; // 10 token/day for pre/public sale
uint256 public finalTimeForFreeMint = 5 minutes; // 150 days
uint256 public finalTimeForDutchMint = 4 minutes; // 100 days
uint256 public maxNoOfdaysForFreeMint = 7; // 216000
uint256 public maxNoOfdaysForDutchMint = 7; // 144000
uint256 public bonusReward = 300 ether; // 300 token bonus
struct User
{
uint256 TotalWithdrawn;
uint256 TotalStaked;
}
mapping(address => uint256[]) public lockedTokenIds;
mapping(address => mapping(uint256 => uint256)) public lockedStakingTime;
mapping(address => User) public UserInfo;
mapping(address=>uint256) public lockedTotalStakedNft;
mapping (address => bool) public alreadyAwarded;
mapping(address => mapping(uint256 => uint256)) public rewardedAmount;
modifier onlyMinter(){
require(msg.sender == address(NFT), "caller is not the minter");
_;
}
function lockedStaking(address _user, uint256 tokenId) external
// onlyMinter
{
lockedTokenIds[_user].push(tokenId);
lockedStakingTime[_user][tokenId] = block.timestamp;
UserInfo[_user].TotalStaked += 1;
lockedTotalStakedNft[_user] += 1;
}
function calcTime(uint256 tokenID) public view returns(uint256) {
uint256 rewardTime;
if(NFT.getIdType(tokenID) == 1){
// if(getType(tokenID) == 1){
rewardTime += (block.timestamp.sub(NFT.getFreeMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForFreeMint){
rewardTime = maxNoOfdaysForFreeMint;
}
}
else if(NFT.getIdType(tokenID) == 2){
rewardTime += (block.timestamp.sub(NFT.getDutchMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForDutchMint){
rewardTime = maxNoOfdaysForDutchMint;
}
}
return rewardTime;
}
function lockedReward(address _user, uint256 tokenId) public view returns(uint256 idReward_){
uint256 reward;
uint256 noOfDays = calcTime(tokenId);
if(NFT.getIdType(tokenId) == 1){
reward += (((noOfDays).mul(rewardFreeMint).mul(1 ether))).div(rewTime);
}
else if(NFT.getIdType(tokenId) == 2){
reward += (((noOfDays).mul(rewardDutchMint)).mul(1 ether)).div(rewTime);
}
return (reward - rewardedAmount[_user][tokenId]);
}
function lockedWithdrawReward(uint256 tokenId) public {
address _user = msg.sender;
uint256 TotalReward;
uint256 reward = lockedReward(_user, tokenId);
rewardedAmount[_user][tokenId] += reward;
if(!alreadyAwarded[_user]){
alreadyAwarded[_user] = true; // true the tokenId type
}
TotalReward = (reward+getBonus(_user));
Token.transfer(_user, reward);
UserInfo[_user].TotalWithdrawn += reward;
}
// this will use in single reward function for presale and public sale mint
function getTokenIdTime(uint256 tokenId) public view returns(uint256){
uint256 MintTime;
if(NFT.getIdType(tokenId) == 1){
MintTime = NFT.getFreeMintingTime(tokenId);
}
else if(NFT.getIdType(tokenId) == 2){
MintTime = NFT.getDutchMintingTime(tokenId);
}
return MintTime;
}
function lockedSingleUnStake(uint256 tokenId) public {
address _user = msg.sender;
uint256 _index = findIndex(tokenId);
require(block.timestamp
> (getTokenIdTime(lockedTokenIds[_user][_index])
+finalTimeForFreeMint),
"time not reached for free mint");
require(block.timestamp
> (getTokenIdTime(lockedTokenIds[_user][_index])
+finalTimeForDutchMint),
"time not reached for dutch mint");
lockedWithdrawReward(tokenId);
NFT.transferFrom(address(this), address(_user), tokenId);
// NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
lockedTokenIds[_user].pop();
NFT.overridee(tokenId);
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
function lockedUnstakeAll() public {
address _user = msg.sender;
uint256 _index;
uint256[] memory tokenIds = getIds(_user);
require(tokenIds.length > 0, "you have no Id to unstake");
for(uint256 i; i< tokenIds.length; i++){
_index = findIndex(tokenIds[i]);
lockedWithdrawReward(lockedTokenIds[_user][_index]);
NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
NFT.overridee(lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
lockedTokenIds[_user].pop();
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
}
function getIds(address _user) public view returns(uint256[] memory){
uint256[] memory tokenIds = new uint256[](getTotalIds(_user).length);
for (uint256 i=0; i< getTotalIds(_user).length; i++){
if(calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForFreeMint
||
calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForDutchMint)
{
tokenIds[i] = lockedTokenIds[_user][i];
}
}
return tokenIds;
}
function getIDType(uint256 tokenId) public view returns(uint256){
return NFT.getIdType(tokenId);
}
function getTotalIds(address _user) public view returns(uint256[] memory){
return lockedTokenIds[_user];
}
function findIndex(uint256 value) public view returns(uint256){
uint256 i = 0;
while(lockedTokenIds[msg.sender][i] != value){
i++;
}
return i;
}
struct user
{
uint256 totlaWithdrawn;
uint256 myNFT;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public userStakingTime;
mapping(address => user) public User_Info;
mapping(address => uint256[]) public userTokenIds;
mapping(address=>uint256) public TotalUserStakedNft;
///////////////////////////////////////////////////////////////////////
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
NFT.transferFrom(msg.sender,address(this),tokenId[i]);
userTokenIds[msg.sender].push(tokenId[i]);
userStakingTime[msg.sender][tokenId[i]]=block.timestamp;
}
User_Info[msg.sender].myNFT += tokenId.length;
TotalUserStakedNft[msg.sender]+=tokenId.length;
}
// function normalCalcTime(uint256 tokenId) public view returns(uint256){
// return timeSlot;
// }
function userSingleReward(address _user,uint256 tokenId) public view returns(uint256 tokenIdReward_){
uint256 reward;
// uint256 _index = find(tokenId);
// uint256 timeSlot = normalCalcTime(userTokenIds[msg.sender][_index]);
uint256 timeSlot = ((block.timestamp).sub(userStakingTime[msg.sender][tokenId])).div(slotTime);
if(NFT.getIdType(tokenId) == 3){
reward += ((timeSlot).mul(commonReward).mul(1 ether)).div(rewTime);
}
else if(NFT.getIdType(tokenId) == 4){
reward += ((timeSlot).mul(genesisRewarad).mul(1 ether)).div(rewTime);
}
return (reward - rewardedAmount[_user][tokenId]);
}
// function userTotalReward(address _user) public view returns(uint256) {
// uint256[] memory tokenIds = userStakedNFT(_user);
// uint256 reward;
// for(uint256 i; i< tokenIds.length; i++){
// reward += userSingleReward(_user, tokenIds[i]);
// }
// return reward;
// }
function withDrawReward(uint256 TokenId) public {
address _user = msg.sender;
uint256 TotalReward;
uint256 reward = userSingleReward(_user, TokenId);
require(reward > 0,"you don't have reward yet!");
if(!alreadyAwarded[_user]){
alreadyAwarded[_user] = true; // true the tokenId type
}
TotalReward = (reward+getBonus(_user));
Token.transfer(_user, TotalReward);
rewardedAmount[_user][TokenId] += reward;
User_Info[msg.sender].totlaWithdrawn += reward;
}
function find(uint value) public view returns(uint) {
uint i = 0;
while (userTokenIds[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256 _tokenId) external
{
withDrawReward(_tokenId);
uint256 _index=find(_tokenId);
require(userTokenIds[msg.sender][_index] ==_tokenId ,"NFT with this _tokenId not found");
NFT.transferFrom(address(this),msg.sender,_tokenId);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index]=userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
userStakingTime[msg.sender][_tokenId]=0;
userTokenIds[msg.sender].pop();
User_Info[msg.sender].myNFT -= 1;
TotalUserStakedNft[msg.sender] > 0 ? TotalUserStakedNft[msg.sender] -= 1 : TotalUserStakedNft[msg.sender]=0;
// emit unstakeSingle(msg.sender, _tokenId);
}
function unStakeAll(uint256[] memory _tokenIds) external
{
for(uint256 i=0;i<_tokenIds.length;i++){
uint256 _index=find(_tokenIds[i]);
require(userTokenIds[msg.sender][_index] ==_tokenIds[i] ,"NFT with this _tokenId not found");
withDrawReward(_tokenIds[i]);
NFT.transferFrom(address(this), msg.sender, _tokenIds[i]);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index ] = userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
userTokenIds[msg.sender].pop();
userStakingTime[msg.sender][_tokenIds[i]]=0;
}
User_Info[msg.sender].myNFT -= _tokenIds.length;
TotalUserStakedNft[msg.sender]>0?TotalUserStakedNft[msg.sender] -= _tokenIds.length:TotalUserStakedNft[msg.sender]=0;
}
function isNormalStaked(address _stakeHolder)public view returns(bool){
if(TotalUserStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return userTokenIds[_staker];
}
function getTime(address _user, uint256 tokenId) public view returns(uint256){
uint256 _time;
uint256 _type = getIDType(tokenId);
if(_type == 1){
_time = NFT.getFreeMintingTime(tokenId);
}
else if(_type == 2){
_time = NFT.getDutchMintingTime(tokenId);
}
else{
_time = userStakingTime[_user][tokenId];
}
return _time;
}
function getReward(address _user, uint256 tokenId) public view returns(uint256){
uint256 _reward;
if(NFT.getIdType(tokenId) == 1 || NFT.getIdType(tokenId) == 2){
_reward = lockedReward(_user, tokenId);
}
else if(NFT.getIdType(tokenId) == 3 || NFT.getIdType(tokenId) == 4){
_reward = userSingleReward(_user, tokenId);
}
return _reward;
}
function getBonus(address _user) public view returns(uint256){
if(!alreadyAwarded[_user]){
return bonusReward;
}
else{
return 0;
}
}
// ===========================================================
// ========================= ADMIN ===========================
function setFreeMintReward(uint256 tokenIdReward) public onlyOwner{
rewardDutchMint = tokenIdReward;
}
function setDutchMintReward(uint256 tokenIdReward) public onlyOwner{
rewardDutchMint = tokenIdReward;
}
function setPublicReward(uint256 tokenIdReward) public onlyOwner{
commonReward = tokenIdReward;
}
function setGenesisReward(uint256 tokenIdReward) public onlyOwner{
genesisRewarad = tokenIdReward;
}
function getStakingTime(address _user, uint256 tokenId) public view returns(uint256){
return userStakingTime[_user][tokenId];
}
}
| 117,123 | 11,415 |
261f99f58659a354f8752fa3ce9866f791994e2882bd0c88af969904b186e2d5
| 13,664 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9348995663aadc44f725eaf56d42c9f74ce0162b.sol
| 3,964 | 11,524 |
pragma solidity >=0.5.8;
contract manekio {
//EVENTS
event playerBet (uint256 BetID,
address playerAddress,
uint256 pick,
uint256 eth);
event playerPaid (uint256 BetID,
address playerAddress,
uint256 pick,
uint256 eth);
event jackpotClaim (uint256 BetID,
address playerAddress,
uint256 eth);
event adminStart (uint256 betID,
uint256 pcknum,
uint256 endtime,
uint256 bEndtime);
event adminEndWin (uint256 betID,
uint256 wPck);
//MODIFIERS
modifier onlyAdministrator(){
address _playerAddress = msg.sender;
require(_playerAddress == admin);
_;
}
//STRUCTURES
struct playerJBook {
uint256 sShare;
uint256 eShare;
}
struct playerBook {
uint256 share;
uint256 eth;
bool paid;
}
struct pickBook {
uint256 share; //number of shares in each
uint256 nBet; //number of player bets (ID)
}
struct betDataBook {
//set when games is started
string pckname;
uint256 pcknum;
uint256 endtime;
uint256 bEndtime;
//in game values
uint256 tShare;
uint256 comm;
uint256 commPaid;
uint256 jackpot;
//current state values
bool started;
bool ended;
bool refund;
//end of game values
uint256 wPck;
uint256 shareval;
uint256 jendblock;
uint256 endblockhash;
address jPotWinner;
bool jPotclaimed;
}
//DATASETS
mapping(uint256 => mapping(address => mapping(uint256 => playerJBook))) internal plyrJBk; //plyrJBk[bID][addr][bet #] = playerJBook addr => bet num => plyrJBk
mapping(uint256 => mapping(address => mapping(uint256 => playerBook))) internal pAddrxBk; //pAddrxBk[bID][addr][pck] = shares address => pick => shares
mapping(uint256 => mapping(uint256 => pickBook)) internal pBk; //total number of N bets & shares
mapping(uint256 => betDataBook) internal bDB; //bDB[bID] = all round data except player data and pick totals
uint256 internal commrate = 25;
uint256 internal jpotrate = 25;
uint256 internal jpotinterval = 6000;
address payable internal admin = 0xe7Cef4D90BdA19A6e2A20F12A1A6C394230d2924;
uint256 internal donations = 0;
uint256 internal donationsPaid = 0;
//FALLBACK FUNCTION
//all eth sent to contract without proper message will dump into pot, comm, and jackpot
function() external payable {
require(msg.value > 0);
donations += msg.value;
}
//PUBLIC FUNCTIONS
//this is where players place their bets
function playerPick(uint256 _bID, uint256 _pck) public payable {
address _pAddr = msg.sender;
uint256 _eth = msg.value;
require(_eth > 0);
//minimum bet entry is .01 eth & player chose a valid pick
if (_eth >= 1e16 && !checkTime(_bID) && !bDB[_bID].ended && _pck <= bDB[_bID].pcknum && bDB[_bID].started && !bDB[_bID].refund) {
//get my fucking money
uint256 _commEth = _eth / commrate;
uint256 _jpEth = _eth / jpotrate;
uint256 _potEth = _eth - _commEth - _jpEth;
//calc shares (each share is .00001 eth)
uint256 _share = _potEth / 1e13;
//update books
bDB[_bID].comm += _commEth;
bDB[_bID].jackpot += _jpEth + (_potEth % 1e13);
pBk[_bID][_pck].nBet += 1;
pBk[_bID][_pck].share += _share;
//update plyrJBk
for(uint256 i = 0; true; i++) {
if(plyrJBk[_bID][_pAddr][i].eShare == 0){
plyrJBk[_bID][_pAddr][i].sShare = bDB[_bID].tShare;
plyrJBk[_bID][_pAddr][i].eShare = bDB[_bID].tShare + _share - 1;
break;
}
}
//update total shares
bDB[_bID].tShare += _share;
//update pAddrxBk
pAddrxBk[_bID][_pAddr][_pck].share += _share;
pAddrxBk[_bID][_pAddr][_pck].eth += _eth;
//fire event
emit playerBet(_bID, _pAddr, _pck, _potEth);
}
else {
donations += _eth;
}
}
//call me if you won the jackpot (can check via checkJPotWinner) which this function also calls
function claimJackpot(uint256 _bID) public {
address payable _pAddr = msg.sender;
uint256 _jackpot = bDB[_bID].jackpot;
require(bDB[_bID].ended == true && checkJPotWinner(_bID, _pAddr) && !bDB[_bID].jPotclaimed && bDB[_bID].refund == false);
bDB[_bID].jPotclaimed = true;
bDB[_bID].jPotWinner = _pAddr;
_pAddr.transfer(_jackpot);
emit jackpotClaim(_bID, _pAddr, _jackpot);
}
//call me if you won and betting is over
function payMeBitch(uint256 _bID, uint256 _pck) public {
address payable _pAddr = msg.sender;
require(pAddrxBk[_bID][_pAddr][_pck].paid == false && pAddrxBk[_bID][_pAddr][_pck].share > 0 && bDB[_bID].wPck == _pck && bDB[_bID].refund == false && bDB[_bID].ended == true);
uint256 _eth = pAddrxBk[_bID][_pAddr][_pck].share * bDB[_bID].shareval;
pAddrxBk[_bID][_pAddr][_pck].paid = true;
_pAddr.transfer(_eth);
emit playerPaid(_bID, _pAddr, _pck, _eth);
}
//call me if a refund was triggered by admin
function giveMeRefund(uint256 _bID, uint256 _pck) public {
address payable _pAddr = msg.sender;
require(bDB[_bID].refund == true);
require(pAddrxBk[_bID][_pAddr][_pck].paid == false && pAddrxBk[_bID][_pAddr][_pck].eth > 0);
pAddrxBk[_bID][_pAddr][_pck].paid = true;
_pAddr.transfer(pAddrxBk[_bID][_pAddr][_pck].eth);
}
//VIEW FUNCTIONS
//checks if a specific address is the jackpot winner for bet
function checkJPotWinner(uint256 _bID, address payable _pAddr) public view returns(bool){
uint256 _endblockhash = bDB[_bID].endblockhash;
uint256 _tShare = bDB[_bID].tShare;
uint256 _nend = nextJPot(_bID);
uint256 _wnum;
require(plyrJBk[_bID][_pAddr][0].eShare != 0);
if (bDB[_bID].jPotclaimed == true) {
return(false);
}
//pseudo random function which adds deadline block to a stored block hash and keccack256 hashes it
_endblockhash = uint256(keccak256(abi.encodePacked(_endblockhash + _nend)));
_wnum = (_endblockhash % _tShare);
for(uint256 i = 0; true; i++) {
if(plyrJBk[_bID][_pAddr][i].eShare == 0){
break;
}
else {
if (plyrJBk[_bID][_pAddr][i].sShare <= _wnum && plyrJBk[_bID][_pAddr][i].eShare >= _wnum){
return(true);
}
}
}
return(false);
}
//returns the current jackpot claim deadline
function nextJPot(uint256 _bID) public view returns(uint256) {
uint256 _cblock = block.number;
uint256 _jendblock = bDB[_bID].jendblock;
uint256 _tmp = (_cblock - _jendblock);
uint256 _nend = _jendblock + jpotinterval;
uint256 _c = 0;
if (bDB[_bID].jPotclaimed == true) {
return(0);
}
while(_tmp > ((_c + 1) * jpotinterval)) {
_c += 1;
}
_nend += jpotinterval * _c;
return(_nend);
}
//GETS FOR POT AND PLAYER STATS
//to view postitions on bet for specific address
function addressPicks(uint256 _bID, address _pAddr, uint256 _pck) public view returns(uint256) {return(pAddrxBk[_bID][_pAddr][_pck].share);}
//checks if an address has been paid
function addressPaid(uint256 _bID, address _pAddr, uint256 _pck) public view returns(bool) {return(pAddrxBk[_bID][_pAddr][_pck].paid);}
//get shares in pot for specified pick
function pickPot(uint256 _bID, uint256 _pck) public view returns(uint256) {return(pBk[_bID][_pck].share);}
//get number of bets for speficied pick
function pickPlyr(uint256 _bID, uint256 _pck) public view returns(uint256) {return(pBk[_bID][_pck].nBet);}
//gets pick pot to pot ratio (bet multipliers)
function pickRatio(uint256 _bID, uint256 _pck) public view returns(uint256) {return(bDB[_bID].tShare * 1e13 / pBk[_bID][_pck].share);}
function getPot(uint256 _bID) public view returns(uint256) {return(bDB[_bID].tShare * 1e13);}
function getJPot(uint256 _bID) public view returns(uint256) {return(bDB[_bID].jackpot);}
function getWPck(uint256 _bID) public view returns(uint256) {return(bDB[_bID].wPck);}
function viewJPotclaimed(uint256 _bID) public view returns(bool) {return(bDB[_bID].jPotclaimed);}
function viewJPotWinner(uint256 _bID) public view returns(address) {return(bDB[_bID].jPotWinner);}
//GETS FOR THINGS SET BY ADMIN WHEN BETTING IS STARTED
function viewPck(uint256 _bID) public view returns(string memory name, uint256 num) {return(bDB[_bID].pckname, bDB[_bID].pcknum);}
function getEndtime(uint256 _bID) public view returns(uint256) {return(bDB[_bID].endtime);}
function getBEndtime(uint256 _bID) public view returns(uint256) {return(bDB[_bID].bEndtime);}
//GETS FOR STATE VARIABLES
function hasStarted(uint256 _bID) public view returns(bool) {return(bDB[_bID].started);}
function isOver(uint256 _bID) public view returns(bool) {return(bDB[_bID].ended);}
function isRefund(uint256 _bID) public view returns(bool){return(bDB[_bID].refund);}
function checkTime(uint256 _bID) public view returns(bool) {
uint256 _now = now;
if (_now < bDB[_bID].endtime) {
return(false);
}
else {
return(true);
}
}
//GETS FOR PAYING ADMIN
function getComm(uint256 _bID) public view returns(uint256 comm, uint256 commPaid) {return(bDB[_bID].comm, bDB[_bID].commPaid);}
function getDon() public view returns(uint256 don, uint256 donPaid) {return(donations, donationsPaid);}
//ADMIN ONLY FUNCTIONS
function adminStartBet(uint256 _bID, string memory _pckname, uint256 _pcknum, uint256 _endtime, uint256 _bEndtime) onlyAdministrator() public {
require(!bDB[_bID].started);
bDB[_bID].pckname = _pckname;
bDB[_bID].pcknum = _pcknum;
bDB[_bID].endtime = _endtime;
bDB[_bID].bEndtime = _bEndtime;
bDB[_bID].started = true;
emit adminStart(_bID, _pcknum, _endtime, _bEndtime);
}
function adminWinner(uint256 _bID, uint256 _wPck) onlyAdministrator() public {
require(_wPck <= bDB[_bID].pcknum && checkTime(_bID) && bDB[_bID].ended == false && bDB[_bID].refund == false);
bDB[_bID].ended = true;
bDB[_bID].wPck = _wPck;
uint256 _shareval = (1e13 * bDB[_bID].tShare) / pBk[_bID][_wPck].share;
bDB[_bID].shareval = _shareval;
uint256 _rem = (1e13 * bDB[_bID].tShare) % pBk[_bID][_wPck].share;
if (_rem > 0) {
donations += _rem;
}
uint256 _jendblock = block.number;
bDB[_bID].jendblock = _jendblock;
//setting the pseudo random block hash of 200 blocks ago
bDB[_bID].endblockhash = uint256(keccak256(abi.encodePacked(blockhash(_jendblock - 200))));
emit adminEndWin(_bID, _wPck);
}
function fuckYouPayMe(uint256 _bID) onlyAdministrator() public {
require(checkTime(_bID) == true && bDB[_bID].refund == false);
uint256 _commDue = bDB[_bID].comm - bDB[_bID].commPaid;
if (_commDue > 0) {
bDB[_bID].commPaid += _commDue;
admin.transfer(_commDue);
}
}
function adminRefund(uint256 _bID) onlyAdministrator() public {
require(bDB[_bID].ended != true && bDB[_bID].refund != true);
bDB[_bID].refund = true;
}
function adminRake() onlyAdministrator() public {
uint256 _donDue = donations - donationsPaid;
if (_donDue > 0) {
donationsPaid += _donDue;
admin.transfer(_donDue);
}
}
}
| 180,589 | 11,416 |
e32eca7e4826f8930f4e8dc4fcfc21287c97ea5d2bd38b32d604b49ddd847a89
| 10,730 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x65171746deb1d6eee256455f77c350eceda34ae2.sol
| 2,703 | 10,155 |
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 AgroNest 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 = "AgroNest";
string public constant symbol = "NEST";
uint public constant decimals = 18;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 10000000000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 200; // 0.005 Ether
uint256 public tokensPerEth = 10000000e18;
uint public target0drop = 1000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x37351E066e89621B0356b970be2C7e3CAE979a9D
;
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 = 4000000000e18;
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 * 20 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 1000e18;
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);
}
}
| 181,645 | 11,417 |
c35f9ecec6ba3d0e3e2c91d3dea3ee31642c64f5bae26bf7da54179e1fc56624
| 16,731 |
.sol
|
Solidity
| false |
376266010
|
Instadapp/dsa-resolvers
|
e1282d30e5b80661055485d83f2ca49fb557c13f
|
contracts/protocols/optimism/uniswap/interfaces.sol
| 3,463 | 14,331 |
// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol";
interface TokenInterface {
function approve(address, uint256) external;
function transfer(address, uint256) external;
function transferFrom(address,
address,
uint256) external;
function deposit() external payable;
function withdraw(uint256) external;
function balanceOf(address) external view returns (uint256);
function decimals() external view returns (uint256);
function totalSupply() external view returns (uint256);
}
/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
/// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
/// @dev In the implementation you must pay the pool tokens owed for the swap.
/// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
/// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
/// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
function uniswapV3SwapCallback(int256 amount0Delta,
int256 amount1Delta,
bytes calldata data) external;
}
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another token
/// @return amountOut The amount of the received token
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
/// @return amountOut The amount of the received token
function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps as little as possible of one token for `amountOut` of another token
/// @return amountIn The amount of the input token
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
/// @return amountIn The amount of the input token
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}
/// @title Creates and initializes V3 Pools
/// require the pool to exist.
interface IPoolInitializer {
/// @notice Creates a new pool if it does not exist, then initializes if not initialized
/// @param token0 The contract address of token0 of the pool
/// @param token1 The contract address of token1 of the pool
/// @param fee The fee amount of the v3 pool for the specified token pair
/// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
function createAndInitializePoolIfNecessary(address token0,
address token1,
uint24 fee,
uint160 sqrtPriceX96) external payable returns (address pool);
}
/// @title Immutable state
/// @notice Functions that return immutable state of the router
interface IPeripheryImmutableState {
/// @return Returns the address of the Uniswap V3 factory
function factory() external view returns (address);
/// @return Returns the address of WETH9
function WETH9() external view returns (address);
}
/// @title Periphery Payments
/// @notice Functions to ease deposits and withdrawals of ETH
interface IPeripheryPayments {
/// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH.
/// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
/// @param amountMinimum The minimum amount of WETH9 to unwrap
/// @param recipient The address receiving ETH
function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;
/// @notice Refunds any ETH balance held by this contract to the `msg.sender`
/// @dev Useful for bundling with mint or increase liquidity that uses ether, or exact output swaps
/// that use ether for the input amount
function refundETH() external payable;
/// @notice Transfers the full amount of a token held by this contract to recipient
/// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
/// @param token The contract address of the token which will be transferred to `recipient`
/// @param amountMinimum The minimum amount of token required for a transfer
/// @param recipient The destination address of the token
function sweepToken(address token,
uint256 amountMinimum,
address recipient) external payable;
}
/// @title ERC721 with permit
/// @notice Extension to ERC721 that includes a permit function for signature based approvals
interface IERC721Permit is IERC721 {
/// @notice The permit typehash used in the permit signature
/// @return The typehash for the permit
function PERMIT_TYPEHASH() external pure returns (bytes32);
/// @notice The domain separator used in the permit signature
/// @return The domain seperator used in encoding of permit signature
function DOMAIN_SEPARATOR() external view returns (bytes32);
/// @notice Approve of a specific token ID for spending by spender via signature
/// @param spender The account that is being approved
/// @param tokenId The ID of the token that is being approved for spending
/// @param deadline The deadline timestamp by which the call must be mined for the approve to work
/// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
/// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
/// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
function permit(address spender,
uint256 tokenId,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external payable;
}
/// @title Non-fungible token for positions
/// and authorized.
interface INonfungiblePositionManager is
IPoolInitializer,
IPeripheryPayments,
IPeripheryImmutableState,
IERC721Metadata,
IERC721Enumerable,
IERC721Permit
{
/// @notice Emitted when liquidity is increased for a position NFT
/// @dev Also emitted when a token is minted
/// @param tokenId The ID of the token for which liquidity was increased
/// @param liquidity The amount by which liquidity for the NFT position was increased
/// @param amount0 The amount of token0 that was paid for the increase in liquidity
/// @param amount1 The amount of token1 that was paid for the increase in liquidity
event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
/// @notice Emitted when liquidity is decreased for a position NFT
/// @param tokenId The ID of the token for which liquidity was decreased
/// @param liquidity The amount by which liquidity for the NFT position was decreased
/// @param amount0 The amount of token0 that was accounted for the decrease in liquidity
/// @param amount1 The amount of token1 that was accounted for the decrease in liquidity
event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
/// @notice Emitted when tokens are collected for a position NFT
/// @param tokenId The ID of the token for which underlying tokens were collected
/// @param recipient The address of the account that received the collected tokens
/// @param amount0 The amount of token0 owed to the position that was collected
/// @param amount1 The amount of token1 owed to the position that was collected
event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);
/// @notice Returns the position information associated with a given token ID.
/// @dev Throws if the token ID is not valid.
/// @param tokenId The ID of the token that represents the position
/// @return nonce The nonce for permits
/// @return operator The address that is approved for spending
/// @return token0 The address of the token0 for a specific pool
/// @return token1 The address of the token1 for a specific pool
/// @return fee The fee associated with the pool
/// @return tickLower The lower end of the tick range for the position
/// @return tickUpper The higher end of the tick range for the position
/// @return liquidity The liquidity of the position
function positions(uint256 tokenId)
external
view
returns (uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1);
struct MintParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
}
/// @notice Creates a new position wrapped in a NFT
/// a method does not exist, i.e. the pool is assumed to be initialized.
/// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
/// @return tokenId The ID of the token that represents the minted position
/// @return liquidity The amount of liquidity for this position
/// @return amount0 The amount of token0
/// @return amount1 The amount of token1
function mint(MintParams calldata params)
external
payable
returns (uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1);
struct IncreaseLiquidityParams {
uint256 tokenId;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
/// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
/// @param params tokenId The ID of the token for which liquidity is being increased,
/// amount0Desired The desired amount of token0 to be spent,
/// amount1Desired The desired amount of token1 to be spent,
/// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
/// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
/// deadline The time by which the transaction must be included to effect the change
/// @return liquidity The new liquidity amount as a result of the increase
/// @return amount0 The amount of token0 to acheive resulting liquidity
/// @return amount1 The amount of token1 to acheive resulting liquidity
function increaseLiquidity(IncreaseLiquidityParams calldata params)
external
payable
returns (uint128 liquidity,
uint256 amount0,
uint256 amount1);
struct DecreaseLiquidityParams {
uint256 tokenId;
uint128 liquidity;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
/// @notice Decreases the amount of liquidity in a position and accounts it to the position
/// @param params tokenId The ID of the token for which liquidity is being decreased,
/// amount The amount by which liquidity will be decreased,
/// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
/// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
/// deadline The time by which the transaction must be included to effect the change
/// @return amount0 The amount of token0 accounted to the position's tokens owed
/// @return amount1 The amount of token1 accounted to the position's tokens owed
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
external
payable
returns (uint256 amount0, uint256 amount1);
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
/// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
/// @param params tokenId The ID of the NFT for which tokens are being collected,
/// recipient The account that should receive the tokens,
/// amount0Max The maximum amount of token0 to collect,
/// amount1Max The maximum amount of token1 to collect
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
/// must be collected first.
/// @param tokenId The ID of the token that is being burned
function burn(uint256 tokenId) external payable;
}
| 1,024 | 11,418 |
faae068ce17b43747ae2c0aa8123854ff8d8e31883a4073fca44063165f9d358
| 24,413 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/voting-0-1/collusion/SBIBank-0x28aC77611bf3ae7B776AC7ecd79119D3C161574D.sol
| 5,580 | 19,357 |
pragma solidity >=0.4.18;
// contract CrowdsaleParameters {
// ///////////////////////////////////////////////////////////////////////////
// // Production Config
// ///////////////////////////////////////////////////////////////////////////
// // ICO period timestamps:
// // 1524182400 = April 20, 2018.
// // 1529452800 = June 20, 2018.
// uint256 public constant generalSaleStartDate = 1524182400;
// uint256 public constant generalSaleEndDate = 1529452800;
// ///////////////////////////////////////////////////////////////////////////
// // QA Config
// ///////////////////////////////////////////////////////////////////////////
// ///////////////////////////////////////////////////////////////////////////
// // Configuration Independent Parameters
// ///////////////////////////////////////////////////////////////////////////
// struct AddressTokenAllocation {
// address addr;
// uint256 amount;
// }
// }
// contract Owned {
// address public owner;
// event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
//
// function Owned() public {
// owner = msg.sender;
// }
// modifier onlyOwner() {
// require(msg.sender == owner);
// _;
// }
//
// function changeOwner(address newOwner) onlyOwner public {
// require(newOwner != address(0));
// require(newOwner != owner);
// OwnershipTransferred(owner, newOwner);
// owner = 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) {
// // 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 SBIToken is Owned, CrowdsaleParameters {
// using SafeMath for uint256;
//
// string public standard = 'ERC20/SBI';
// string public name = 'Subsoil Blockchain Investitions';
// string public symbol = 'SBI';
// uint8 public decimals = 18;
//
// mapping (address => uint256) private balances;
// mapping (address => mapping (address => uint256)) private allowed;
// mapping (address => mapping (address => bool)) private allowanceUsed;
//
// event Transfer(address indexed from, address indexed to, uint tokens);
// event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
// event Issuance(uint256 _amount); // triggered when the total supply is increased
// event Destruction(uint256 _amount); // triggered when the total supply is decreased
// event NewSBIToken(address _token);
//
// uint256 public totalSupply = 0; // 40000000;
// bool public transfersEnabled = true;
//
// function SBIToken() public {
// owner = msg.sender;
// mintToken(generalSaleWallet);
// mintToken(bounty);
// mintToken(partners);
// mintToken(team);
// NewSBIToken(address(this));
// }
// modifier transfersAllowed {
// require(transfersEnabled);
// _;
// }
// modifier onlyPayloadSize(uint size) {
// assert(msg.data.length >= size + 4);
// _;
// }
//
// function approveCrowdsale(address _crowdsaleAddress) external onlyOwner {
// approveAllocation(generalSaleWallet, _crowdsaleAddress);
// }
// uint uintDecimals = decimals;
// uint exponent = 10**uintDecimals;
// uint amount = tokenAllocation.amount * exponent;
// allowed[tokenAllocation.addr][_crowdsaleAddress] = amount;
// Approval(tokenAllocation.addr, _crowdsaleAddress, amount);
// }
//
// function balanceOf(address _address) public constant returns (uint256 balance) {
// return balances[_address];
// }
//
// return allowed[_owner][_spender];
// }
//
// require(_to != address(0));
// require(_value <= balances[msg.sender]);
// balances[msg.sender] = balances[msg.sender].sub(_value);
// balances[_to] = balances[_to].add(_value);
// Transfer(msg.sender, _to, _value);
// return true;
// }
//
// function mintToken(AddressTokenAllocation tokenAllocation) internal {
// uint uintDecimals = decimals;
// uint exponent = 10**uintDecimals;
// uint mintedAmount = tokenAllocation.amount * exponent;
// // Mint happens right here: Balance becomes non-zero from zero
// balances[tokenAllocation.addr] += mintedAmount;
// totalSupply += mintedAmount;
// // Emit Issue and Transfer events
// Issuance(mintedAmount);
// Transfer(address(this), tokenAllocation.addr, mintedAmount);
// }
//
// require(_value == 0 || allowanceUsed[msg.sender][_spender] == false);
// allowed[msg.sender][_spender] = _value;
// allowanceUsed[msg.sender][_spender] = false;
// Approval(msg.sender, _spender, _value);
// return true;
// }
//
// 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() public {}
//
// function toggleTransfers(bool _enable) external onlyOwner {
// transfersEnabled = _enable;
// }
// }
//
// contract SBIBank is Owned, CrowdsaleParameters {
// using SafeMath for uint256;
// string public name = 'Subsoil Blockchain Investitions Bank';
// SBIToken private token;
// uint256 public currentVotingDate = 0;
// uint public currentVotingAmount = 0;
// uint public allowedWithdraw = 0;
// uint public allowedRefund = 0;
// uint256 public toAllow = 0;
// uint256 public toCancel = 0;
// uint256 public toRefund = 0;
// // result of a voiting
// uint8 result = 0;
// address sbiBank = this;
// // investors votes
// mapping(address => uint8) public votes;
// // investors votes dates
// mapping(address => uint256) public voteDates;
// // investors refunded amounts of voting
// mapping(address => uint256) public alreadyRefunded;
// event NewIncomingFunds(uint indexed amount, address indexed sender);
// event NewVoting(uint256 indexed date, uint indexed amount);
// event NewVote(address indexed voter, uint256 indexed date, uint8 indexed proposal);
// event CancelVote(uint256 indexed date, uint indexed amount);
// event AllowVote(uint256 indexed date, uint indexed amount);
// event RefundVote(uint256 indexed date, uint indexed amount);
// event Refund(uint256 indexed date, uint256 indexed amount, address indexed investor);
// event Withdraw(uint256 indexed date, uint indexed amount);
//
// function SBIBank(address _tokenAddress) public payable {
// token = SBIToken(_tokenAddress);
// }
//
// function addVoting(uint _amount) public onlyOwner {
// require(sbiBank.balance >= _amount);
// // can add only if previouse voiting closed
// require(currentVotingDate == 0 && currentVotingAmount == 0);
// currentVotingDate = now;
// currentVotingAmount = _amount;
// NewVoting(now, _amount);
// }
//
// function voteOf(address voter) public constant returns (uint8 vote) {
// return votes[voter];
// }
//
// function vote(uint8 proposal) public returns(uint8 prop) {
// require(token.balanceOf(msg.sender) > 0);
// require(now >= currentVotingDate && now <= currentVotingDate + 3 days);
// require(proposal == 1 || proposal == 2 || proposal == 3);
// // you can vote only once for current voiting
// require(voteDates[msg.sender] != currentVotingDate);
// alreadyRefunded[msg.sender] = 0;
// votes[msg.sender] = proposal;
// voteDates[msg.sender] = currentVotingDate;
// if(proposal == 1) {
// toAllow = toAllow + token.balanceOf(msg.sender);
// }
// if(proposal == 2) {
// toCancel = toCancel + token.balanceOf(msg.sender);
// }
// if(proposal == 3) {
// toRefund = toRefund + token.balanceOf(msg.sender);
// }
// NewVote(msg.sender, now, proposal);
// return proposal;
// }
//
// function endVoting() public onlyOwner {
// require(currentVotingDate > 0 && now >= currentVotingDate + 3 days);
// if (toAllow > toCancel && toAllow > toRefund) {
// // toAllow withdraw
// AllowVote(currentVotingDate, toAllow);
// allowedWithdraw = currentVotingAmount;
// allowedRefund = 0;
// }
// if (toCancel > toAllow && toCancel > toRefund) {
// // toCancel voiting
// CancelVote(currentVotingDate, toCancel);
// allowedWithdraw = 0;
// allowedRefund = 0;
// }
// if (toRefund > toAllow && toRefund > toCancel) {
// // toCancel voiting
// RefundVote(currentVotingDate, toRefund);
// allowedRefund = currentVotingAmount;
// allowedWithdraw = 0;
// }
// currentVotingDate = 0;
// currentVotingAmount = 0;
// toAllow = 0;
// toCancel = 0;
// toRefund = 0;
// }
//
// function withdraw() public onlyOwner {
// require(currentVotingDate == 0);
// require(allowedWithdraw > 0);
// owner.transfer(allowedWithdraw);
// Withdraw(now, allowedWithdraw);
// allowedWithdraw = 0;
// }
//
// function refund() public {
// require(allowedRefund > 0);
// // allows refund only once thrue the voiting
// require(alreadyRefunded[msg.sender] == 0);
// require(token.balanceOf(msg.sender) > 0);
// // total supply tokens is 40 000 000
// uint256 tokensPercent = token.balanceOf(msg.sender).div(40000000).div(1000000000000000);
// uint256 refundedAmount = tokensPercent.mul(sbiBank.balance).div(1000);
// address sender = msg.sender;
// alreadyRefunded[msg.sender] = refundedAmount;
// token.transferFrom(msg.sender, featureDevelopment.addr, token.balanceOf(msg.sender));
// sender.transfer(refundedAmount);
// Refund(now, refundedAmount, msg.sender);
// }
//
// function () external payable {
// NewIncomingFunds(msg.value, msg.sender);
// }
// }
contract Rewrite{
uint[] voteCount;
struct Proposal{
bytes32 name;
}
Proposal[] proposals;
mapping(address=>uint) voteDates;
mapping(address=>uint) votes;
mapping(address=>uint) alreadyRefunded;
uint currentVotingDate;
uint currentVotingAmount;
uint allowedWithdraw;
uint allowedRefund;
uint toAllow;
uint toCancel;
uint toRefund;
uint _winner;
function newProposal(uint numOfProposal) public {
proposals.length = numOfProposal;
}
function vote(address msg_sender, uint proposal) public returns(uint prop) {
require(proposal == 1 || proposal == 2 || proposal == 3);
// you can vote only once for current voiting
require(voteDates[msg_sender] != currentVotingDate);
alreadyRefunded[msg_sender] = 0;
votes[msg_sender] = proposal;
voteDates[msg_sender] = currentVotingDate;
if(proposal == 1) {
toAllow = toAllow + 1;
}
if(proposal == 2) {
toCancel = toCancel + 1;
}
if(proposal == 3) {
toRefund = toRefund + 1;
}
return proposal;
}
function endVoting() public {
if (toAllow > toCancel && toAllow > toRefund) {
// toAllow withdraw
allowedWithdraw = currentVotingAmount;
allowedRefund = 0;
_winner = 1;
}
if (toCancel > toAllow && toCancel > toRefund) {
// toCancel voiting
allowedWithdraw = 0;
allowedRefund = 0;
_winner = 2;
}
if (toRefund > toAllow && toRefund > toCancel) {
// toCancel voiting
allowedRefund = currentVotingAmount;
allowedWithdraw = 0;
_winner = 3;
}
currentVotingDate = 0;
currentVotingAmount = 0;
toAllow = 0;
toCancel = 0;
toRefund = 0;
}
function getWinner() public returns (uint winnerName){
return _winner;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
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_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint p1, uint p1_value, uint p1_rv_value, uint msg_value1,
address payable msg_sender2, uint p2, uint p2_value, uint p2_rv_value, uint msg_value2,
address payable msg_sender3, uint p3, uint p3_value, uint p3_rv_value, uint msg_value3,
address payable msg_sender4, uint p4, uint p4_value, uint p4_rv_value, uint msg_value4,
address payable msg_sender5, uint p5, uint p5_value, uint p5_rv_value, uint msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value==1&&p1_value > p1_rv_value && p1_rv_value ==0);
require(p2_value==1&&p2_value > p2_rv_value && p2_rv_value ==0);
require(p3_value==1&&p3_value > p3_rv_value && p3_rv_value ==0);
require(p4_value==1&&p4_value > p4_rv_value && p4_rv_value ==0);
require(p5_value==1&&p5_value > p5_rv_value && p5_rv_value ==0);
require(p1 == 1 || p1 == 2 || p1 == 3);
require(p2 == 1 || p2 == 2 || p2 == 3);
require(p3 == 1 || p3 == 2 || p3 == 3);
require(p4 == 1 || p4 == 2 || p4 == 3);
require(p5 == 1 || p5 == 2 || p5 == 3);
require(msg_value1 == 1 || msg_value1 == 2 || msg_value1 == 3);
require(msg_value2 == 1 || msg_value2 == 2 || msg_value2 == 3);
require(msg_value3 == 1 || msg_value3 == 2 || msg_value3 == 3);
require(msg_value4 == 1 || msg_value4 == 2 || msg_value4 == 3);
require(msg_value5 == 1 || msg_value5 == 2 || msg_value5 == 3);
require(votes[msg_sender1] == 0);
require(votes[msg_sender5] == 0);
require(votes[msg_sender2] == 0);
require(votes[msg_sender3] == 0);
require(votes[msg_sender4] == 0);
require(voteDates[msg_sender1] == 0);
require(voteDates[msg_sender2] == 0);
require(voteDates[msg_sender3] == 0);
require(voteDates[msg_sender4] == 0);
require(voteDates[msg_sender5] == 0);
require(alreadyRefunded[msg_sender1] == 0);
require(alreadyRefunded[msg_sender2] == 0);
require(alreadyRefunded[msg_sender3] == 0);
require(alreadyRefunded[msg_sender4] == 0);
require(alreadyRefunded[msg_sender5] == 0);
require(currentVotingDate==100);
// require(currentVotingAmount==0);//slack variable
require(toAllow==0&&
toCancel==0&&
toRefund==0);
// new proposal first
uint winner;
require(winner==0);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
// require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
// votes
vote(msg_sender1, msg_value1);
vote(msg_sender2, msg_value2);
vote(msg_sender3, msg_value3);
vote(msg_sender4, msg_value4);
vote(msg_sender5, msg_value5);
//execute Proposal
endVoting();
winner = getWinner();
if (winner == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if (winner == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if (winner == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if (winner == msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if (winner == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_collusion_violate_check(utilities[msg_sender1], msg_value1, p1, msg_value2, p2);
}
}
| 242,292 | 11,419 |
fa6f9c6bfc7e068a18af6030eb637ffcce3f86454487b5fe617f22d77faed44a
| 25,566 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGuqamRYGwG7mgRjMfWVsPZ5WmYm3k6MCr_Orixhem_Contract.sol
| 8,984 | 24,199 |
//SourceUnit: orixhem.sol
pragma solidity ^0.4.24;
contract Orixhem_Contract {
address private owner;
address private orixhem_R;
constructor() public{
owner = msg.sender;
}
struct persona {
uint id;
address billetera;
string eth;
string pack;
uint ref;
uint acumulado;
uint acumulado_total;
uint nivel;
uint limite_referido;
uint[] equipo;
uint pagos;
}
mapping (address => persona) private nodo;
mapping (uint=> persona) public id_nodo;
uint ids=1;
uint[] private personas_array;
uint private firma=0;
uint private personascont=0;
uint public suny=1000000;
bool genesis=false;
function paquetes(uint _i,uint ref) public payable{
require(nodo[msg.sender].id==0);
if (_i == 0) {
require (msg.value== 400 trx);
send_owner(80*suny);
add(20,"400","Pack0",ref,0,220,48,52,20,8,12);
} else if (_i == 1) {
require (msg.value== 800 trx);
send_owner(160*suny);
add(40,"800","Pack1",ref,1,440,96,104,40,16,24);
} else if (_i == 2) {
require (msg.value== 1600 trx);
send_owner(320*suny);
add(80,"1600","Pack2",ref,2,880,192,208,80,32,48);
} else if (_i == 3) {
require (msg.value== 3200 trx);
send_owner(640*suny);
add(160,"3200","Pack3",ref,3,1760,384,416,160,64,96);
}
else if (_i == 4) {
require (msg.value== 6400 trx);
send_owner(1280*suny);
add(320,"6400","Pack4",ref,4,3520,768,832,320,128,192);
}
else if (_i == 5) {
require (msg.value== 12800 trx);
send_owner(2560*suny);
add(640,"12800","Pack5",ref,5,7040,1536,1664,640,256,384);
}
else if (_i == 6) {
require (msg.value== 25600 trx);
send_owner(5120*suny);
add(1280,"25600","Pack6",ref,6,14080,3072,3328,1280,512,768);
}
else if (_i == 7) {
require (msg.value== 44000 trx);
send_owner(8800*suny);
add(2200,"44000","Pack7",ref,7,24200,5280,5720,2200,880,1320);
}
else if (_i == 8) {
require (msg.value== 77000 trx);
send_owner(15400*suny);
add(3850,"77000","Pack8",ref,8,42350,9240,10010,3850,1540,2310);
}
else if (_i == 9) {
require (msg.value== 144000 trx);
send_owner(28800*suny);
add(7200,"144000","Pack9",ref,9,79200,17280,18720,7200,2880,4320);
}
else if (_i == 10) {
require (msg.value== 288000 trx);
send_owner(57600*suny);
add(14400,"288000","Pack10",ref,10,158400,34560,37440,14400,5760,8640);
}
else if (_i == 11) {
require (msg.value== 576000 trx);
send_owner(115200*suny);
add(28800,"576000","Pack11",ref,11,316800,69120,74880,28800,11520,17280);
}
while(hay_pagos()){
pago_automatico();
}
}
function add(uint _acumulado,string _eth,string _pack,uint _referido,uint _nivel,uint pago50,uint pago10,uint pago10a,uint pago5,uint pago2,uint pago3) private {
require(buscar_referido(_referido));
require(!limite_de_referido(_referido));
persona storage personas=nodo[msg.sender];
persona storage personas_id=id_nodo[ids];
personas_id.id=ids;
personas_id.billetera = msg.sender;
personas_id.eth=_eth;
personas_id.pack=_pack;
personas_id.ref=_referido;
personas_id.acumulado=_acumulado;
personas_id.acumulado_total=_acumulado;
personas_id.nivel=_nivel;
personas_id.pagos=0;
personas.id=ids;
personas.billetera = msg.sender;
personas.eth=_eth;
personas.pack=_pack;
personas.ref=_referido;
personas.acumulado=_acumulado;
personas.acumulado_total=_acumulado;
personas.nivel=_nivel;
personas.pagos=0;
personascont++;
personas_array.push(ids);
asignar_equipo(_referido,ids);
asignar_pago(_referido,pago50,pago10,pago10a,pago5,pago2,pago3);
asignar_referido(_referido);
// pago_automatico();
ids=ids+1;
}
function seach_address(address a) view public returns (uint) {
return (nodo[a].id);
}
function seach_id(uint a) view public returns (uint, address,string,string) {
return (id_nodo[a].id,id_nodo[a].billetera,id_nodo[a].eth,id_nodo[a].pack);
}
function dinero (uint a)view public returns (uint,uint,uint,uint,uint,uint){
return(id_nodo[a].ref,id_nodo[a].acumulado,id_nodo[a].acumulado_total,id_nodo[a].nivel,id_nodo[a].limite_referido,id_nodo[a].pagos);
}
function buscar_referido(uint a) private returns(bool){
if(!genesis){
genesis=true;
return true;
}else {
if(id_nodo[a].id!=0){
return true;
}
else{
return false;
}
}
}
function send_owner(uint amount) private {
orixhem_R.transfer(amount);
}
function buscar_familia(uint a)private view returns(uint){
uint count=0;
if(id_nodo[a].id!=0){
count++;
if(id_nodo[id_nodo[a].ref].id !=0){
count++;
if(id_nodo[id_nodo[id_nodo[a].ref].ref].id!=0){
count++;
}
}
}
return count;
}
function limite_de_referido(uint a) private view returns(bool){
if(id_nodo[a].limite_referido==3){
return true;
}else{
return false;
}
}
function asignar_referido(uint a) private{
id_nodo[a].limite_referido= id_nodo[a].limite_referido+1;
}
function asignar_equipo (uint a,uint per) private {
id_nodo[a].equipo.push(per);
}
function asignar_pago(uint a,uint _50,uint _10,uint _a10,uint _5,uint _2,uint _3)private {
//pago 50%
uint d=id_nodo[a].id;
//pago 10%
uint b=id_nodo[id_nodo[a].ref].id;
//pago 10%
uint c=id_nodo[id_nodo[id_nodo[a].ref].ref].id;
//pagos acumuladoi
//TOTAL ACUMULADO IMPORTANTE
id_nodo[d].acumulado=id_nodo[d].acumulado+_50;
id_nodo[d].acumulado=id_nodo[d].acumulado-_5;
id_nodo[d].acumulado=id_nodo[d].acumulado+_2;
//TOTAL ACUMULADO GLOBAL
id_nodo[d].acumulado_total=id_nodo[d].acumulado_total+_50;
id_nodo[d].acumulado_total=id_nodo[d].acumulado_total-_5;
id_nodo[d].acumulado_total=id_nodo[d].acumulado_total+_2;
//TOTAL ACUMULADO IMPORTANTE
id_nodo[b].acumulado=id_nodo[b].acumulado+_10;
id_nodo[b].acumulado=id_nodo[b].acumulado-_2;
id_nodo[b].acumulado=id_nodo[b].acumulado+_3;
//TOTAL ACUMULADO GLOBAL
id_nodo[b].acumulado_total=id_nodo[b].acumulado_total+_10;
id_nodo[b].acumulado_total=id_nodo[b].acumulado_total-_2;
id_nodo[b].acumulado_total=id_nodo[b].acumulado_total+_3;
//TOTAL ACUMULADO IMPORTANTE
id_nodo[c].acumulado=id_nodo[c].acumulado+_a10;
id_nodo[c].acumulado=id_nodo[c].acumulado-_3;
//TOTAL ACUMULADO GLOBAL
id_nodo[c].acumulado_total=id_nodo[c].acumulado_total+_a10;
id_nodo[c].acumulado_total=id_nodo[c].acumulado_total-_3;
}
function mirar_refidos(uint a) public view returns(uint[]){
return id_nodo[a].equipo;
}
function mirar_personas()public view returns(uint[]){
return personas_array;
}
function pago_automatico() public {
for (uint i = 1; i<=personas_array.length; i++){
uint level=id_nodo[i].nivel;
uint acum=id_nodo[i].acumulado;
address direccion=id_nodo[i].billetera;
if(level ==0){
if((id_nodo[i].pagos==0 &&acum >= 200) || (id_nodo[i].pagos==1 && acum>=600)){
send_pays(200*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=1200){
id_nodo[i].pagos=0;
id_nodo[i].nivel=1;
id_nodo[i].eth="800";
id_nodo[i].pack="Pack1";
send_owner(160*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-400;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+40;
id_nodo[i].acumulado=id_nodo[i].acumulado+40;
// resto de reinversion
id_nodo[i].acumulado=id_nodo[i].acumulado-800;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,440,96,104,40,16,24);
}
}
if(level ==1){
if((id_nodo[i].pagos==0 &&acum >= 400) || (id_nodo[i].pagos==1 && acum>=1200)){
send_pays(400*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=2400){
id_nodo[i].pagos=0;
id_nodo[i].nivel=2;
id_nodo[i].eth="1600";
id_nodo[i].pack="Pack2";
send_owner(320*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-800;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+80;
id_nodo[i].acumulado=id_nodo[i].acumulado+80;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-1600;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,880,192,208,80,32,48);
}
}
if(level ==2){
if((id_nodo[i].pagos==0 &&acum >= 800) || (id_nodo[i].pagos==1 && acum>=2400)){
send_pays(800*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=4800){
id_nodo[i].pagos=0;
id_nodo[i].nivel=3;
id_nodo[i].eth="3200";
id_nodo[i].pack="Pack3";
send_owner(640*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-1600;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+160;
id_nodo[i].acumulado=id_nodo[i].acumulado+160;
// resto de reinversion 0.60
id_nodo[i].acumulado=id_nodo[i].acumulado-3200;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,1760,384,416,160,64,96);
}
}
if(level ==3){
if((id_nodo[i].pagos==0 &&acum >= 1600) || (id_nodo[i].pagos==1 && acum>=4800)){
send_pays(1600*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=9600){
id_nodo[i].pagos=0;
id_nodo[i].nivel=4;
id_nodo[i].eth="6400";
id_nodo[i].pack="Pack4";
send_owner(1280*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-3200;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+320;
id_nodo[i].acumulado=id_nodo[i].acumulado+320;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-6400;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,3520,768,832,320,128,192);
}
}
if(level ==4){
if((id_nodo[i].pagos==0 &&acum >= 3200) || (id_nodo[i].pagos==1 && acum>=9600)){
send_pays(3200*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=19200){
id_nodo[i].pagos=0;
id_nodo[i].nivel=5;
id_nodo[i].eth="12800";
id_nodo[i].pack="Pack5";
send_owner(2560*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-6400;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+640;
id_nodo[i].acumulado=id_nodo[i].acumulado+640;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-12800;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,7040,1536,1664,640,256,384);
}
}
if(level ==5){
if((id_nodo[i].pagos==0 &&acum >= 6400) || (id_nodo[i].pagos==1 && acum>=19200)){
send_pays(6400*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=38400){
id_nodo[i].pagos=0;
id_nodo[i].nivel=6;
id_nodo[i].eth="25600";
id_nodo[i].pack="Pack6";
send_owner(5120*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-12800;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+1280;
id_nodo[i].acumulado=id_nodo[i].acumulado+1280;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-25600;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,14080,3072,3328,1280,512,768);
}
}
if(level ==6){
if((id_nodo[i].pagos==0 &&acum >= 12800) || (id_nodo[i].pagos==1 && acum>=38400)){
send_pays(12800*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=76800){
id_nodo[i].pagos=0;
id_nodo[i].nivel=7;
id_nodo[i].eth="44000";
id_nodo[i].pack="Pack7";
send_owner(8800*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-25600;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+2200;
id_nodo[i].acumulado=id_nodo[i].acumulado+2200;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-44000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,24200,5280,5720,2200,880,1320);
}
}
if(level ==7){
if((id_nodo[i].pagos==0 &&acum >= 22000) || (id_nodo[i].pagos==1 && acum>=66000)){
send_pays(22000*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=132000){
id_nodo[i].pagos=0;
id_nodo[i].nivel=8;
id_nodo[i].eth="77000";
id_nodo[i].pack="Pack8";
send_owner(15400*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-44000;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+3850;
id_nodo[i].acumulado=id_nodo[i].acumulado+3850;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-77000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,42350,9240,10010,3850,1540,2310);
}
}
if(level ==8){
if((id_nodo[i].pagos==0 &&acum >= 38500) || (id_nodo[i].pagos==1 && acum>=115500)){
send_pays(38500*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=231000){
id_nodo[i].pagos=0;
id_nodo[i].nivel=9;
id_nodo[i].eth="144000";
id_nodo[i].pack="Pack9";
send_owner(28800*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-77000;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+7200;
id_nodo[i].acumulado=id_nodo[i].acumulado+7200;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-144000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,79200,17280,18720,7200,2880,4320);
}
}
if(level ==9){
if((id_nodo[i].pagos==0 &&acum >= 72000) || (id_nodo[i].pagos==1 && acum>=216000)){
send_pays(72000*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=432000){
id_nodo[i].pagos=0;
id_nodo[i].nivel=10;
id_nodo[i].eth="288000";
id_nodo[i].pack="Pack10";
send_owner(57600*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-144000;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+14400;
id_nodo[i].acumulado=id_nodo[i].acumulado+14400;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-288000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,158400,34560,37440,14400,5760,8640);
}
}
if(level ==10){
if((id_nodo[i].pagos==0 &&acum >= 144000) || (id_nodo[i].pagos==1 && acum>=432000)){
send_pays(144000*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=864000){
id_nodo[i].pagos=0;
id_nodo[i].nivel=11;
id_nodo[i].eth="576000";
id_nodo[i].pack="Pack11";
send_owner(115200*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-288000;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+28800;
id_nodo[i].acumulado=id_nodo[i].acumulado+28800;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-576000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,316800,69120,74880,28800,11520,17280);
}
}
if(level ==11){
if((id_nodo[i].pagos==0 &&acum >= 288000) || (id_nodo[i].pagos==1 && acum>=864000)){
send_pays(288000*suny,direccion);
id_nodo[i].pagos++;
}
if(id_nodo[i].pagos==2 && acum>=1728000){
id_nodo[i].pagos=0;
id_nodo[i].nivel=11;
id_nodo[i].eth="576000";
id_nodo[i].pack="Pack11";
send_owner(115200*suny);
//resto pago de los caminos
id_nodo[i].acumulado=id_nodo[i].acumulado-576000;
//sumo del 30% el 5 que baja
id_nodo[i].acumulado_total=id_nodo[i].acumulado_total+28800;
id_nodo[i].acumulado=id_nodo[i].acumulado+28800;
// resto de reinversion 0.30
id_nodo[i].acumulado=id_nodo[i].acumulado-576000;
//reinversion a los padres
asignar_pago(id_nodo[i].ref,316800,69120,74880,28800,11520,17280);
}
}
}
}
function send_pays(uint amount,address to)private{
require(address(this).balance >=amount);
require(to != address(0));
to.transfer(amount);
}
function mirar_arrat(uint a)public view returns(uint){
return personas_array[a];
}
function hay_pagos() public view returns(bool){
for (uint i = 1; i<=personas_array.length; i++){
uint level=id_nodo[i].nivel;
uint acum=id_nodo[i].acumulado;
if(level == 0 && ((id_nodo[i].pagos==0 &&acum >= 200) || (id_nodo[i].pagos==1 && acum>=600) || (id_nodo[i].pagos==2 && acum>=1200))){
return true;
}
if(level == 1 && ((id_nodo[i].pagos==0 &&acum >= 400) || (id_nodo[i].pagos==1 && acum>=1200) || (id_nodo[i].pagos==2 && acum>=2400))){
return true;
}
if(level == 2 && ((id_nodo[i].pagos==0 &&acum >= 800) || (id_nodo[i].pagos==1 && acum>=2400) || (id_nodo[i].pagos==2 && acum>=4800))){
return true;
}
if(level == 3 && ((id_nodo[i].pagos==0 &&acum >= 1600) || (id_nodo[i].pagos==1 && acum>=4800) || (id_nodo[i].pagos==2 && acum>=9600))){
return true;
}
if(level == 4 && ((id_nodo[i].pagos==0 &&acum >= 3200) || (id_nodo[i].pagos==1 && acum>=9600) || (id_nodo[i].pagos==2 && acum>=19200))){
return true;
}
if(level == 5 && ((id_nodo[i].pagos==0 &&acum >= 6400) || (id_nodo[i].pagos==1 && acum>=19200) || (id_nodo[i].pagos==2 && acum>=38400))){
return true;
}
if(level == 6 && ((id_nodo[i].pagos==0 &&acum >= 12800) || (id_nodo[i].pagos==1 && acum>=38400) || (id_nodo[i].pagos==2 && acum>=76800))){
return true;
}
if(level == 7 && ((id_nodo[i].pagos==0 &&acum >= 22000) || (id_nodo[i].pagos==1 && acum>=66000) || (id_nodo[i].pagos==2 && acum>=132000))){
return true;
}
if(level == 8 && ((id_nodo[i].pagos==0 &&acum >= 38500) || (id_nodo[i].pagos==1 && acum>=115500) || (id_nodo[i].pagos==2 && acum>=231000))){
return true;
}
if(level == 9 && ((id_nodo[i].pagos==0 &&acum >= 72000) || (id_nodo[i].pagos==1 && acum>=216000) || (id_nodo[i].pagos==2 && acum>=432000))){
return true;
}
if(level == 10 && ((id_nodo[i].pagos==0 &&acum >= 144000) || (id_nodo[i].pagos==1 && acum>=432000) || (id_nodo[i].pagos==2 && acum>=864000))){
return true;
}
if(level == 11 && ((id_nodo[i].pagos==0 &&acum >= 288000) || (id_nodo[i].pagos==1 && acum>=864000) || (id_nodo[i].pagos==2 && acum>=1728000))){
return true;
}
}
return false;
}
function pago(uint amount,address to)public isowner{
require(address(this).balance >=amount);
require(to != address(0));
to.transfer(amount);
}
modifier isowner(){
require(msg.sender==owner);
_;
}
function alimentador() public payable {
require(msg.value== 1000 trx);
}
function addPrincipal(address cov) public returns(string){
if(firma==0){
orixhem_R=cov;
firma=1;
return "registro correcto";
}
}
}
| 298,939 | 11,420 |
1094d90678bc1eb01460b9973f2b2c2b09254268429fa2a577af42d8526ec50e
| 13,663 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x36f0deb0af8ab453b6b4fcc8b0b7fe2f1b44e55f.sol
| 3,009 | 11,029 |
pragma solidity ^0.4.19;
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 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;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223 {
uint public totalSupply;
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint);
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 custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract INZEI is ERC223, Ownable {
using SafeMath for uint256;
string public name = "INZEI";
string public symbol = "INZ";
uint8 public decimals = 8;
uint256 public initialSupply = 10e9 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping (address => uint) balances;
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 burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function INZEI() public {
totalSupply = initialSupply;
balances[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 (uint balance) {
return balances[_owner];
}
modifier onlyPayloadSize(uint256 size){
assert(msg.data.length >= size + 4);
_;
}
// Function that is called when a user or another contract wants to transfer funds .
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)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Function that is called when a user or another contract wants to transfer funds .
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);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
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]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
// retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != 0x0);
frozenAccount[targets[i]] = isFrozen;
FrozenFunds(targets[i], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint i = 0; i < targets.length; i++){
require(unlockUnixTime[targets[i]] < unixTimes[i]);
unlockUnixTime[targets[i]] = unixTimes[i];
LockedFunds(targets[i], unixTimes[i]);
}
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf(_from) >= _unitAmount);
balances[_from] = SafeMath.sub(balances[_from], _unitAmount);
totalSupply = SafeMath.sub(totalSupply, _unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = SafeMath.add(totalSupply, _unitAmount);
balances[_to] = SafeMath.add(balances[_to], _unitAmount);
Mint(_to, _unitAmount);
bytes memory empty;
Transfer(address(0), _to, _unitAmount, empty);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeTokens(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = SafeMath.mul(amount, 1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
bytes memory empty;
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
balances[addresses[i]] = SafeMath.add(balances[addresses[i]], amount);
Transfer(msg.sender, addresses[i], amount, empty);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
bytes memory empty;
for (uint i = 0; i < addresses.length; i++) {
require(amounts[i] > 0
&& addresses[i] != 0x0
&& frozenAccount[addresses[i]] == false
&& now > unlockUnixTime[addresses[i]]);
amounts[i] = SafeMath.mul(amounts[i], 1e8);
require(balances[addresses[i]] >= amounts[i]);
balances[addresses[i]] = SafeMath.sub(balances[addresses[i]], amounts[i]);
totalAmount = SafeMath.add(totalAmount, amounts[i]);
Transfer(addresses[i], msg.sender, amounts[i], empty);
}
balances[msg.sender] = SafeMath.add(balances[msg.sender], 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);
bytes memory empty;
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount, empty);
}
function() payable public {
autoDistribute();
}
}
| 209,629 | 11,421 |
800f6a191ed43f3feaa7319aee698ec0d0b37a65ed76a0da26e5644876841d6a
| 19,245 |
.sol
|
Solidity
| false |
324650154
|
jashmenn/smart-wallet-factory
|
f886784c69f9bc749e4c9fa4ae07ee071f1925c2
|
Flattened.sol
| 3,218 | 13,063 |
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
interface IWalletFactory {
function updateOwnershipRecord(address _oldOwner) external;
}
interface IWallet {
function owner() external view returns (address);
}
interface ICHI {
function freeFromUpTo(address _addr, uint256 _amount) external returns (uint256);
}
contract FactoryNotifier {
IWalletFactory immutable private _factory;
constructor() {
_factory = IWalletFactory(msg.sender);
}
function factory() public view returns (IWalletFactory) { return _factory; }
function _notifyFactory(address _oldOwner) internal {
factory().updateOwnershipRecord(_oldOwner);
}
}
contract Ownable is FactoryNotifier {
address private _owner;
address private _pendingOwner;
constructor(address _initialOwner) {
_owner = _initialOwner;
}
modifier onlyOwner() {
require(msg.sender == _owner, "Ownable::onlyOwner: Not owner.");
_;
}
modifier onlyPendingOwner() {
require(msg.sender == _pendingOwner, "Ownable::onlyPendingOwner: Not pending owner.");
_;
}
// functions on the Wallet contract".
// so that the owner can "offer ownership" and also make other calls in a single transaction.
modifier onlyAuthorizedCaller() {
require(msg.sender == _owner || msg.sender == address(this), "Ownable::onlyAuthorizedCaller: Not authorized caller.");
_;
}
event OwnershipOffered(address indexed owner, address indexed pendingOwner);
event OwnershipTaken(address indexed oldOwner, address indexed newOnwer);
// on the Wallet contract
function offerOwnership(address _newPendingOwner) external onlyAuthorizedCaller {
require(_newPendingOwner != _owner, "Ownable::offerOwnership: Owner cannot transfer ownership to self."); // prevents UI confusion
require(_newPendingOwner != address(this), "Ownable::offerOwnership: Wallet cannot own itself."); // removes a footgun (would brick the wallet)
_pendingOwner = _newPendingOwner;
emit OwnershipOffered(_owner, _newPendingOwner);
}
function takeOwnership() external onlyPendingOwner {
// transfer ownership
address oldOwner = _owner;
address newOwner = _pendingOwner;
_owner = newOwner;
// remove _pendingOwner
_pendingOwner = address(0);
// notify the factory of the ownership change
_notifyFactory(oldOwner);
emit OwnershipTaken(oldOwner, newOwner);
}
function owner() public view returns (address) { return _owner; }
function pendingOwner() public view returns (address) { return _pendingOwner; }
}
contract CHIEnabled {
ICHI constant private chi = ICHI(0x0000000000004946c0e9F43F4Dee607b0eF1fA1c);
modifier useCHI {
uint256 gasStart = gasleft();
_;
uint256 gasSpent = 21000 + gasStart - gasleft() + (16 * msg.data.length);
chi.freeFromUpTo(msg.sender, (gasSpent + 14154) / 41947);
}
}
contract Wallet is Ownable, CHIEnabled {
fallback () external payable {}
receive() external payable {}
constructor(address _initialOwner) Ownable(_initialOwner) { }
event ExecuteTransaction(address target, uint256 value, string signature, bytes data, bytes returnData);
function _execute(address _target, uint256 _value, string memory _signature, bytes memory _data) private {
bytes memory callData;
if (bytes(_signature).length == 0) {
callData = _data;
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(_signature))), _data);
}
// solium-disable-next-line
(bool success, bytes memory returnData) = _target.call{value: _value}(callData);
require(success, "Wallet::executeTransaction: Transaction execution reverted.");
emit ExecuteTransaction(_target, _value, _signature, _data, returnData);
}
function _executeMany(address[] memory _targets, uint256[] memory _values, string[] memory _signatures, bytes[] memory _data) private {
uint256 numInputs = _targets.length;
require(_values.length == numInputs && _signatures.length == numInputs && _data.length == numInputs,
"Wallet::executeMany: Invalid input lengths.");
for (uint256 i = 0; i < numInputs; i++) {
_execute(_targets[i], _values[i], _signatures[i], _data[i]);
}
}
function execute(address _target, uint256 _value, string memory _signature, bytes memory _data) external payable onlyOwner {
_execute(_target, _value, _signature, _data);
}
function executeWithCHI(address _target, uint256 _value, string memory _signature, bytes memory _data) external payable useCHI onlyOwner {
_execute(_target, _value, _signature, _data);
}
function executeMany(address[] memory _targets, uint256[] memory _values, string[] memory _signatures, bytes[] memory _data) external payable onlyOwner {
_executeMany(_targets, _values, _signatures, _data);
}
function executeManyWithCHI(address[] memory _targets, uint256[] memory _values, string[] memory _signatures, bytes[] memory _data) external payable useCHI onlyOwner {
_executeMany(_targets, _values, _signatures, _data);
}
}
contract WalletFactory is CHIEnabled {
using EnumerableSet for EnumerableSet.AddressSet;
mapping (address => bool) private _factoryCreatedWallet;
mapping (address => EnumerableSet.AddressSet) private _ownerToWallets;
event NewWalletCreated(address indexed owner, address walletAddress);
event OwnershipTransferred(address indexed wallet, address indexed oldOwner, address indexed newOwner);
// create new wallet
function _createNewWallet() private returns (address) {
address newWalletAddress = address(new Wallet(msg.sender));
_factoryCreatedWallet[newWalletAddress] = true;
require(_ownerToWallets[msg.sender].add(newWalletAddress), "Factory::createNewWallet: Failed to add record.");
emit NewWalletCreated(msg.sender, newWalletAddress);
return newWalletAddress;
}
// create new wallet
function createNewWallet() external returns (address) {
return _createNewWallet();
}
// create new wallet
function createNewWalletWithCHI() external useCHI returns (address) {
return _createNewWallet();
}
// update ownership record upon notification
function updateOwnershipRecord(address _oldOwner) external {
require(isFactoryCreatedWallet(msg.sender), "Wallet::updateOwnershipRecord: Not factory created wallet.");
require(_ownerToWallets[_oldOwner].contains(msg.sender), "Wallet::updateOwnershipRecord: The address did not own this wallet.");
address newOwner = IWallet(msg.sender).owner();
require(_ownerToWallets[_oldOwner].remove(msg.sender), "Wallet::updateOwnershipRecord: Error removing wallet record.");
require(_ownerToWallets[newOwner].add(msg.sender), "Wallet::updateOwnershipRecord: Error adding wallet record.");
emit OwnershipTransferred(msg.sender, _oldOwner, newOwner);
}
// check whether a given wallet was created by this factory
function isFactoryCreatedWallet(address _walletAddress) public view returns (bool) {
return _factoryCreatedWallet[_walletAddress];
}
// check whether a given user is registered as owning a given wallet
function userOwnsWallet(address _user, address _wallet) external view returns (bool) {
return _ownerToWallets[_user].contains(_wallet);
}
// returns the number of wallets registered to a given user
function ownerWalletCount(address _owner) external view returns (uint256) {
return _ownerToWallets[_owner].length();
}
function ownerWalletAt(address _owner, uint256 _index) external view returns (address) {
return _ownerToWallets[_owner].at(_index);
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
| 258,387 | 11,422 |
2c2abe7c70e8a466c438b1933cbb12bbf80a06f75dfd7d7fdb314df5b9feaf7f
| 12,297 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3d/3d2974768901DA9A883cea4976DCFce763E071b2_MIMStaker.sol
| 3,704 | 11,760 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract MIMStaker {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 10 ether;
uint256[] public REFERRAL_PERCENTS = [40, 20, 10];
uint256 constant public PROJECT_FEE1 = 130;
uint256 constant public PROJECT_FEE2 = 110;
uint256 constant public PROJECT_FEE3 = 90;
uint256 constant public PERCENT_STEP = 3;
uint256 constant public WITHDRAW_FEE = 100; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
address constant public token = 0xf8bfd3BFF5B27fD682A70FD4C4Fd5D0d4cdD3Cd7;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address public commissionWallet1;
address public commissionWallet2;
address public commissionWallet3;
address public commissionWallet4;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address wallet1, address wallet2, address wallet3, address wallet4, uint256 startDate) {
require(!isContract(wallet1) && !isContract(wallet2) && !isContract(wallet3) && !isContract(wallet4));
require(startDate > 0);
commissionWallet1 = wallet1;
commissionWallet2 = wallet2;
commissionWallet3 = wallet3;
commissionWallet4 = wallet4;
startUNIX = startDate;
plans.push(Plan(7, 80));
plans.push(Plan(14, 75));
plans.push(Plan(28, 70));
plans.push(Plan(7, 80));
plans.push(Plan(14, 75));
plans.push(Plan(28, 70));
}
function invest(address referrer, uint256 investedAmount, uint8 plan) public {
require(investedAmount >= INVEST_MIN_AMOUNT,"too small");
require(plan < 6, "Invalid plan");
ERC20(token).transferFrom(msg.sender, address(this), investedAmount);
uint256 fee = 0;
if (plan == 0 || plan == 3) {
fee = investedAmount.mul(PROJECT_FEE1).div(PERCENTS_DIVIDER);
} else if (plan == 1 || plan == 4) {
fee = investedAmount.mul(PROJECT_FEE2).div(PERCENTS_DIVIDER);
} else if (plan == 2 || plan == 5) {
fee = investedAmount.mul(PROJECT_FEE3).div(PERCENTS_DIVIDER);
}
ERC20(token).transfer(commissionWallet1, fee.div(4));
ERC20(token).transfer(commissionWallet2, fee.div(4));
ERC20(token).transfer(commissionWallet3, fee.div(4));
ERC20(token).transfer(commissionWallet4, fee.div(4));
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = investedAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, investedAmount);
user.deposits.push(Deposit(plan, percent, investedAmount, profit, block.timestamp, finish));
totalStaked = totalStaked.add(investedAmount);
emit NewDeposit(msg.sender, plan, percent, investedAmount, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = getContractBalance();
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
ERC20(token).transfer(msg.sender, totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return ERC20(token).balanceOf(address(this));
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
interface ERC20 {
/// @param _owner The address from which the balance will be retrieved
/// @return balance the balance
function balanceOf(address _owner) external view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return success Whether the transfer was successful or not
function transfer(address _to, uint256 _value) external returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return success Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return success Whether the approval was successful or not
function approve(address _spender , uint256 _value) external returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return remaining Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 108,106 | 11,423 |
c527ef95f6a29c66b6114b89afcf78868d41005c26b6dc7198658c741f1b6d48
| 34,935 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3b/3b588bf94005bdbb554f7f3e249f04a874f406cd_golf.sol
| 4,182 | 15,998 |
// File: contracts/Golf.sol
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
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) (token/ERC20/ERC20.sol)
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 {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
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);
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
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());
}
}
// 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);
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
contract golf is ERC20, ERC20Burnable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private _maxCap = 1000000000 * 10**decimals();
bool public isAntiBot;
uint256 public maxBuy = 5000 * 10**decimals();
uint256 public maxSell = 5000 * 10**decimals();
uint256 public antiBotStart;
uint256 public antiBotEnd;
uint256 public constant PER_DIVI = 10000;
uint256 public sellTax = 400; // 4%
uint256 public buyTax = 0; // 0%
address public feeWallet;
mapping(address => bool) public lps;
mapping(address => bool) public blacklisted;
mapping(address => bool) public whitelisted;
event SetAntiBot(bool IsAntiBot);
event SetMaxSell(uint256 MaxSell);
event SetMaxBuy(uint256 MaxBuy);
event SetAntiBotTime(uint256 antiBotStart, uint256 antiBotEnd);
event SetLiquidPair(address LP, bool Status);
constructor() ERC20('golf', 'GLF') {
_mint(msg.sender, _maxCap);
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override whenNotPaused {
require(!blacklisted[from] && !blacklisted[to], "Transfer blacklisted");
if (isAntiBot == true && antiBotStart < block.timestamp && block.timestamp < antiBotEnd) {
antiBot(from, to, amount);
}
super._beforeTokenTransfer(from, to, amount);
}
function _transfer(address from,
address to,
uint256 amount) internal override whenNotPaused{
if (lps[from] == true && !whitelisted[to] && buyTax > 0 && feeWallet != address(0)) {
uint256 fee = amount.mul(buyTax).div(PER_DIVI);
uint256 transferA = amount.sub(fee);
super._transfer(from, feeWallet, fee);
super._transfer(from, to, transferA);
}
else if (lps[to] == true && !whitelisted[from] && sellTax > 0 && feeWallet != address(0)) {
uint256 fee = amount.mul(sellTax).div(PER_DIVI);
uint256 transferA = amount.sub(fee);
super._transfer(from, feeWallet, fee);
super._transfer(from, to, transferA);
}
else {
super._transfer(from, to, amount);
}
}
function setAntiBot(bool _isEnabled) external onlyOwner {
isAntiBot = _isEnabled;
emit SetAntiBot(_isEnabled);
}
function antiBot(address _sender,
address _recipient,
uint256 _amount) internal view {
if (lps[_sender] == true && !whitelisted[_recipient]) {
if (_amount > maxBuy) {
revert("Anti bot buy");
}
}
if (lps[_recipient] == true && !whitelisted[_sender]) {
if (_amount > maxSell) {
revert("Anti bot sell");
}
}
}
function blacklist(address _user, bool _isBlacklisted) external onlyOwner {
blacklisted[_user] = _isBlacklisted;
}
function whitelist(address _user, bool _enable) external onlyOwner {
whitelisted[_user] = _enable;
}
function setMaxSell(uint256 _maxSell) external onlyOwner {
maxSell = _maxSell;
emit SetMaxSell(_maxSell);
}
function setMaxBuy(uint256 _maxBuy) external onlyOwner {
maxBuy = _maxBuy;
emit SetMaxBuy(_maxBuy);
}
function setAntiBotTime(uint256 _antiBotStart,
uint256 _antiBotEnd) external onlyOwner {
antiBotStart = _antiBotStart;
antiBotEnd = _antiBotEnd;
emit SetAntiBotTime(_antiBotEnd, _antiBotEnd);
}
function setLiquidPair(address _lp, bool _status) external onlyOwner {
require(address(0) != _lp,"_lp zero address");
lps[_lp] = _status;
emit SetLiquidPair(_lp, _status);
}
function setFeeWallet(address _feeWallet) public onlyOwner {
feeWallet = _feeWallet;
}
function setSellTax(uint256 _taxPercent) public onlyOwner {
sellTax = _taxPercent;
}
function setBuyTax(uint256 _taxPercent) public onlyOwner {
buyTax = _taxPercent;
}
function rescueStuckToken(address _token, address _to) external onlyOwner {
require(_token != address(this),"Invalid token");
uint256 _amount = ERC20(_token).balanceOf(address(this));
ERC20(_token).transfer(_to, _amount);
}
}
| 313,452 | 11,424 |
309a1d1a55db2c487c2f268862e0edcdce58c52462311643d598146e7a5a555f
| 9,127 |
.sol
|
Solidity
| false |
428431140
|
D3LAB-DAO/Governor-C
|
9c7a6c4064476a277ee0df69eeb7282de6719a7f
|
contracts/governance/GovernorCharlieInterfaces.sol
| 1,884 | 8,660 |
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.0;
contract GovernorBravoEvents {
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
/// @param voter The address which casted a vote
/// @param proposalId The proposal id which was voted on
/// @param support Support value for the vote. 0=against, 1=for, 2=abstain
/// @param votes Number of votes which were cast by the voter
/// @param reason The reason given for the vote by the voter
event VoteCast(address indexed voter, uint proposalId, uint8 support, uint votes, string reason);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
/// @notice An event emitted when the voting delay is set
event VotingDelaySet(uint oldVotingDelay, uint newVotingDelay);
/// @notice An event emitted when the voting period is set
event VotingPeriodSet(uint oldVotingPeriod, uint newVotingPeriod);
/// @notice Emitted when implementation is changed
event NewImplementation(address oldImplementation, address newImplementation);
/// @notice Emitted when proposal threshold is set
event ProposalThresholdSet(uint oldProposalThreshold, uint newProposalThreshold);
/// @notice Emitted when pendingAdmin is changed
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
/// @notice Emitted when pendingAdmin is accepted, which means admin is updated
event NewAdmin(address oldAdmin, address newAdmin);
/// @notice Emitted when whitelist account expiration is set
event WhitelistAccountExpirationSet(address account, uint expiration);
/// @notice Emitted when the whitelistGuardian is set
event WhitelistGuardianSet(address oldGuardian, address newGuardian);
}
contract GovernorCharlieEvents is GovernorBravoEvents {
/// @notice An event emitted when a proposal has been finalized
event ProposalFinalized(uint id);
/// @notice An event emitted when a single vote has been finalized
event FinalizeCast(address indexed voter, uint proposalId, uint votes);
/// @notice An event emitted when the aggregating period is set
event AggregatingPeriodSet(uint oldAggregatingPeriod, uint newAggregatingPeriod);
}
contract GovernorBravoDelegatorStorage {
/// @notice Administrator for this contract
address public admin;
/// @notice Pending administrator for this contract
address public pendingAdmin;
/// @notice Active brains of Governor
address public implementation;
}
contract GovernorCharlieDelegatorStorage is GovernorBravoDelegatorStorage { }
contract GovernorBravoDelegateStorageV1 is GovernorBravoDelegatorStorage {
/// @notice The delay before voting on a proposal may take place, once proposed, in blocks
uint public votingDelay;
/// @notice The duration of voting on a proposal, in blocks
uint public votingPeriod;
/// @notice The number of votes required in order for a voter to become a proposer
uint public proposalThreshold;
/// @notice Initial proposal id set at become
uint public initialProposalId;
/// @notice The total number of proposals
uint public proposalCount;
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
CompInterface public comp;
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Current number of votes for abstaining for this proposal
uint abstainVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal or abstains
uint8 support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
}
contract GovernorBravoDelegateStorageV2 is GovernorBravoDelegateStorageV1 {
/// @notice Stores the expiration of account whitelist status as a timestamp
mapping (address => uint) public whitelistAccountExpirations;
/// @notice Address which manages whitelisted proposals and whitelist accounts
address public whitelistGuardian;
}
contract GovernorCharlieDelegateStorage is GovernorBravoDelegateStorageV2 {
/// @notice The duration of aggregating on a proposal, in blocks
uint public aggregatingPeriod;
/// @notice Struct for Chainlink random
struct FlagedRandom {
uint randomValue;
uint returnTimestamp;
}
/// @notice Global mapping for Chainlink random
mapping (bytes32 => FlagedRandom) public flagedRandoms; // Chainlink Random
/// @notice Extra proposal metadata for PQV
struct PqvMeta {
/// @notice Base random number
bytes32 baseFlagedRandom;
/// @notice Flag marking whether the proposal has been finalized for aggregating
uint finalizedTime;
/// @notice Aggregated number of votes in favor of this proposal
uint aggregatedForVotes;
/// @notice Aggregated number of votes in opposition to this proposal
uint aggregatedAgainstVotes;
/// @notice Aggregated number of votes for abstaining for this proposal
uint aggregatedAbstainVotes;
}
/// @notice Global mapping for PQV metadata
mapping (uint => PqvMeta) public pqvMetas;
/// @notice Keys for `receipts` mapping
mapping (uint => address[]) public participants;
/// @notice Indivisual random number
mapping (uint => mapping (address => bytes32)) public myFlagedRandoms;
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface CompInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 23,662 | 11,425 |
08c09adde24b1da6b12dd3394aa2d719bad3e6463e8c2b230b8481f1282d258f
| 21,302 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x1590088b0003d63319bbfdb523e6f5966b18b6d0.sol
| 5,229 | 20,506 |
pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
// Standard token interface (ERC 20)
// https://github.com/ethereum/EIPs/issues/20
contract Token is SafeMath {
// Functions:
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
function transfer(address _to, uint256 _value) returns(bool) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value)returns(bool){}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StdToken is Token {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Functions:
function transfer(address _to, uint256 _value) returns(bool){
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
return true;
}
function 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];
}
modifier onlyPayloadSize(uint _size) {
require(msg.data.length >= _size + 4);
_;
}
}
contract MNTP is StdToken {
/// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * (1 ether / 1 wei);
/// Modifiers:
modifier onlyCreator() {
require(msg.sender == creator);
_;
}
modifier byCreatorOrIcoContract() {
require((msg.sender == creator) || (msg.sender == icoContractAddress));
_;
}
function setCreator(address _creator) onlyCreator {
creator = _creator;
}
/// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
icoContractAddress = _icoContractAddress;
}
/// Functions:
/// @dev Constructor
function MNTP() {
creator = msg.sender;
// 10 mln tokens total
assert(TOTAL_TOKEN_SUPPLY == (10000000 * (1 ether / 1 wei)));
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
require(!lockTransfers);
return super.transfer(_to,_value);
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
require(!lockTransfers);
return super.transferFrom(_from,_to,_value);
}
function issueTokens(address _who, uint _tokens) byCreatorOrIcoContract {
require((totalSupply + _tokens) <= TOTAL_TOKEN_SUPPLY);
balances[_who] = safeAdd(balances[_who],_tokens);
totalSupply = safeAdd(totalSupply,_tokens);
}
function burnTokens(address _who, uint _tokens) byCreatorOrIcoContract {
balances[_who] = safeSub(balances[_who], _tokens);
totalSupply = safeSub(totalSupply, _tokens);
}
function lockTransfer(bool _lock) byCreatorOrIcoContract {
lockTransfers = _lock;
}
// Do not allow to send money directly to this contract
function() {
revert();
}
}
// This contract will hold all tokens that were unsold during ICO
// (Goldmint should be able to withdraw them and sold only 1 year post-ICO)
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
creator = msg.sender;
teamAccountAddress = _teamAccountAddress;
mntToken = MNTP(_mntTokenAddress);
}
modifier onlyCreator() {
require(msg.sender==creator);
_;
}
modifier onlyIcoContract() {
require(msg.sender==icoContractAddress);
_;
}
/// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
icoContractAddress = _icoContractAddress;
}
// only by Goldmint contract
function finishIco() public onlyIcoContract {
icoIsFinishedDate = uint64(now);
}
// can be called by anyone...
function withdrawTokens() public {
// wait for 1 year!
uint64 oneYearPassed = icoIsFinishedDate + 365 days;
require(uint(now) >= oneYearPassed);
// transfer all tokens from this contract to the teamAccountAddress
uint total = mntToken.balanceOf(this);
mntToken.transfer(teamAccountAddress,total);
}
// Default fallback function
function() payable {
revert();
}
}
contract FoundersVesting is SafeMath {
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
teamAccountAddress = _teamAccountAddress;
lastWithdrawTime = uint64(now);
mntToken = MNTP(_mntTokenAddress);
}
// can be called by anyone...
function withdrawTokens() public {
// 1 - wait for next month!
uint64 oneMonth = lastWithdrawTime + 30 days;
require(uint(now) >= oneMonth);
// 2 - calculate amount (only first time)
if(withdrawsCount==0){
amountToSend = mntToken.balanceOf(this) / 10;
}
require(amountToSend!=0);
// 3 - send 1/10th
uint currentBalance = mntToken.balanceOf(this);
if(currentBalance<amountToSend){
amountToSend = currentBalance;
}
mntToken.transfer(teamAccountAddress,amountToSend);
// 4 - update counter
withdrawsCount++;
lastWithdrawTime = uint64(now);
}
// Default fallback function
function() payable {
require(false);
}
}
contract Goldmint is SafeMath {
address public creator = 0x0;
address public tokenManager = 0x0;
address public multisigAddress = 0x0;
address public otherCurrenciesChecker = 0x0;
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
struct TokenBuyer {
uint weiSent;
uint tokensGot;
}
mapping(address => TokenBuyer) buyers;
// These can be changed before ICO start ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// coinmarketcap.com 14.08.2017
uint constant ETH_PRICE_IN_USD = 300;
// price changes from block to block
//uint public constant SINGLE_BLOCK_LEN = 700000;
// TODO: only for tests. DO NOT merge this to master!!!
uint public constant SINGLE_BLOCK_LEN = 100;
///////
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * (1 ether/ 1 wei);
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * (1 ether / 1 wei);
// 7 000 000 we sell only this amount of tokens during the ICO
//uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * (1 ether / 1 wei);
// TODO: only for tests. DO NOT merge this to master!!!
// 150 - we sell only this amount of tokens during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 150 * (1 ether / 1 wei);
// 150 000 tokens soft cap
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * (1 ether / 1 wei);
// this is total number of tokens sold during ICO
uint public icoTokensSold = 0;
// this is total number of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// this is total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
bool public foundersRewardsMinted = false;
bool public restTokensMoved = false;
// this is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
ICOFinished,
Refunding
}
State public currentState = State.Init;
/// Modifiers:
modifier onlyCreator() {
require(msg.sender==creator);
_;
}
modifier onlyTokenManager() {
require(msg.sender==tokenManager);
_;
}
modifier onlyOtherCurrenciesChecker() {
require(msg.sender==otherCurrenciesChecker);
_;
}
modifier onlyInState(State state){
require(state==currentState);
_;
}
/// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
/// Functions:
/// @dev Constructor
function Goldmint(address _multisigAddress,
address _tokenManager,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
creator = msg.sender;
multisigAddress = _multisigAddress;
tokenManager = _tokenManager;
otherCurrenciesChecker = _otherCurrenciesChecker;
mntToken = MNTP(_mntTokenAddress);
unsoldContract = GoldmintUnsold(_unsoldContractAddress);
// slight rename
foundersRewardsAccount = _foundersVestingAddress;
}
/// @dev This function is automatically called when ICO is started
/// WARNING: can be called multiple times!
function startICO() internal onlyCreator {
mintFoundersRewards(foundersRewardsAccount);
mntToken.lockTransfer(true);
if(icoStartedTime==0){
icoStartedTime = uint64(now);
}
}
function pauseICO() internal onlyCreator {
}
function startRefunding() internal onlyCreator {
// only switch to this state if less than ICO_TOKEN_SOFT_CAP sold
require(icoTokensSold<ICO_TOKEN_SOFT_CAP);
// in this state tokens still shouldn't be transferred
assert(mntToken.lockTransfers());
}
/// @dev This function is automatically called when ICO is finished
/// WARNING: can be called multiple times!
function finishICO() internal {
mntToken.lockTransfer(false);
if(!restTokensMoved){
restTokensMoved = true;
// move all unsold tokens to unsoldTokens contract
icoTokensUnsold = safeSub(ICO_TOKEN_SUPPLY_LIMIT,icoTokensSold);
if(icoTokensUnsold>0){
mntToken.issueTokens(unsoldContract,icoTokensUnsold);
unsoldContract.finishIco();
}
}
// send all ETH to multisig
if(this.balance>0){
multisigAddress.transfer(this.balance);
}
}
function mintFoundersRewards(address _whereToMint) internal onlyCreator {
if(!foundersRewardsMinted){
foundersRewardsMinted = true;
mntToken.issueTokens(_whereToMint,FOUNDERS_REWARD);
}
}
/// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
tokenManager = _new;
}
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
function getTokensIcoSold() constant public returns (uint){
return icoTokensSold;
}
function getTotalIcoTokens() constant public returns (uint){
return ICO_TOKEN_SUPPLY_LIMIT;
}
function getMntTokenBalance(address _of) constant public returns (uint){
return mntToken.balanceOf(_of);
}
function getCurrentPrice()constant public returns (uint){
return getMntTokensPerEth(icoTokensSold);
}
function getBlockLength()constant public returns (uint){
return SINGLE_BLOCK_LEN;
}
////
function isIcoFinished() public returns(bool){
if(icoStartedTime==0){return false;}
// 1 - if time elapsed
uint64 oneMonth = icoStartedTime + 30 days;
if(uint(now) > oneMonth){return true;}
// 2 - if all tokens are sold
if(icoTokensSold>=ICO_TOKEN_SUPPLY_LIMIT){
return true;
}
return false;
}
function setState(State _nextState) public {
// only creator can change state
// but in case ICOFinished -> anyone can do that after all time is elapsed
bool icoShouldBeFinished = isIcoFinished();
bool allow = (msg.sender==creator) || (icoShouldBeFinished && (State.ICOFinished==_nextState));
require(allow);
bool canSwitchState
= (currentState == State.Init && _nextState == State.ICORunning)
|| (currentState == State.ICORunning && _nextState == State.ICOPaused)
|| (currentState == State.ICOPaused && _nextState == State.ICORunning)
|| (currentState == State.ICORunning && _nextState == State.ICOFinished)
|| (currentState == State.ICORunning && _nextState == State.Refunding);
require(canSwitchState);
currentState = _nextState;
LogStateSwitch(_nextState);
if(currentState==State.ICORunning){
startICO();
}else if(currentState==State.ICOFinished){
finishICO();
}else if(currentState==State.ICOPaused){
pauseICO();
}else if(currentState==State.Refunding){
startRefunding();
}
}
function getMntTokensPerEth(uint tokensSold) public constant returns (uint){
// 10 buckets
uint priceIndex = (tokensSold / (1 ether/ 1 wei)) / SINGLE_BLOCK_LEN;
assert(priceIndex>=0 && (priceIndex<=9));
uint8[10] memory discountPercents = [20,15,10,8,6,4,2,0,0,0];
// We have to multiply by '1 ether' to avoid float truncations
// Example: ($7000 * 100) / 120 = $5833.33333
uint pricePer1000tokensUsd =
((STD_PRICE_USD_PER_1000_TOKENS * 100) * (1 ether / 1 wei)) / (100 + discountPercents[priceIndex]);
// Correct: 300000 / 5833.33333333 = 51.42857142
// We have to multiply by '1 ether' to avoid float truncations
uint mntPerEth = (ETH_PRICE_IN_USD * 1000 * (1 ether / 1 wei) * (1 ether / 1 wei)) / pricePer1000tokensUsd;
return mntPerEth;
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
require(msg.value!=0);
// The price is selected based on current sold tokens.
// Price can 'overlap'. For example:
// 1. if currently we sold 699950 tokens (the price is 10% discount)
// 2. buyer buys 1000 tokens
// 3. the price of all 1000 tokens would be with 10% discount!!!
uint newTokens = (msg.value * getMntTokensPerEth(icoTokensSold)) / (1 ether / 1 wei);
issueTokensInternal(_buyer,newTokens);
// update 'buyers' map
// (only when buying from ETH)
TokenBuyer memory b = buyers[msg.sender];
b.weiSent = safeAdd(b.weiSent, msg.value);
b.tokensGot = safeAdd(b.tokensGot, newTokens);
buyers[msg.sender] = b;
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _wei_count) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
require(_wei_count!=0);
uint newTokens = (_wei_count * getMntTokensPerEth(icoTokensSold)) / (1 ether / 1 wei);
issueTokensInternal(_to,newTokens);
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyInState(State.ICOFinished) onlyTokenManager {
// can not issue more than BONUS_REWARD
require((issuedExternallyTokens + _tokens)<=BONUS_REWARD);
mntToken.issueTokens(_to,_tokens);
issuedExternallyTokens = issuedExternallyTokens + _tokens;
}
function issueTokensInternal(address _to, uint _tokens) internal {
require((icoTokensSold + _tokens)<=ICO_TOKEN_SUPPLY_LIMIT);
mntToken.issueTokens(_to,_tokens);
icoTokensSold+=_tokens;
LogBuy(_to,_tokens);
}
function burnTokens(address _from, uint _tokens) public onlyInState(State.ICOFinished) onlyTokenManager {
mntToken.burnTokens(_from,_tokens);
LogBurn(_from,_tokens);
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
address sender = msg.sender;
require(0!=buyers[sender].weiSent);
require(0!=buyers[sender].tokensGot);
// 1 - send money back
sender.transfer(buyers[sender].weiSent);
// 2 - burn tokens
mntToken.burnTokens(sender,buyers[sender].tokensGot);
}
// Default fallback function
function() payable {
// buyTokens -> issueTokensInternal
buyTokens(msg.sender);
}
}
| 144,829 | 11,426 |
40b654dc2a243ee09f6a8658c6b3d0cba3de52d3c76ca0bc9a4890a975fdcfe6
| 27,718 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5a/5acb4958bf5cb51fb15852f9e709f392ffe02394_PiggyBankStaking.sol
| 4,335 | 17,218 |
// 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 sPB 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 sPB 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 IsPiggyBank {
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);
}
interface ReferralBonus {
function getReferral(address _account) external view returns(address);
function getRefBonus() external view returns(uint256);
}
contract PiggyBankStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable PiggyBank;
address public immutable sPiggyBank;
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 _PiggyBank,
address _sPiggyBank,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_PiggyBank != address(0));
PiggyBank = _PiggyBank;
require(_sPiggyBank != address(0));
sPiggyBank = _sPiggyBank;
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(PiggyBank).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(IsPiggyBank(sPiggyBank).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sPiggyBank).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, IsPiggyBank(sPiggyBank).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsPiggyBank(sPiggyBank).balanceForGons(info.gons));
IERC20(PiggyBank).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(sPiggyBank).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(PiggyBank).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsPiggyBank(sPiggyBank).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsPiggyBank(sPiggyBank).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 = IsPiggyBank(sPiggyBank).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(PiggyBank).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sPiggyBank).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sPiggyBank).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;
}
}
| 85,728 | 11,427 |
19c64af44225255f01a03e9dc1f5d354d98606ed769812953ee757956060f224
| 10,865 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0f17caa887cd584ebe662f15f48545085142304e.sol
| 3,053 | 10,737 |
pragma solidity 0.4.21;
// Wolf Crypto presale pooling contract
// written by @iamdefinitelyahuman
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20 {
function balanceOf(address _owner) external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
}
interface WhiteList {
function checkMemberLevel (address addr) external view returns (uint);
}
library PresaleLib {
using SafeMath for uint;
WhiteList constant whitelistContract = WhiteList(0x8D95B038cA80A986425FA240C3C17Fb2B6e9bc63);
uint constant contributionMin = 100000000000000000;
uint constant maxGasPrice = 50000000000;
struct Contributor {
uint16 claimedTokensIndex;
uint balance;
}
struct Data {
address owner;
address receiver;
address[] withdrawToken;
bool poolSubmitted;
bool locked;
uint addressSetTime;
uint fee;
uint contractCap;
uint finalBalance;
uint[] withdrawAmount;
uint[] capAmounts;
uint32[] capTimes;
mapping (address => uint) tokenBalances;
mapping (address => uint) individualCaps;
mapping (address => Contributor) contributorMap;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event ReceiverAddressSet (address addr);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalAvailable (address token);
event WithdrawalClaimed (address receiver, address token, uint amount);
modifier onlyOwner (Data storage self) {
require (msg.sender == self.owner);
_;
}
modifier noReentrancy(Data storage self) {
require(!self.locked);
self.locked = true;
_;
self.locked = false;
}
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20).div(denominator);
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct).div(10 ** 20);
}
function newPool (Data storage self, uint _fee, address _receiver, uint _contractCap, uint _individualCap) public {
require (_fee < 1000);
self.owner = msg.sender;
self.receiver = _receiver;
self.contractCap = _contractCap;
self.capTimes.push(0);
self.capAmounts.push(_individualCap);
self.fee = _toPct(_fee,1000);
}
function deposit (Data storage self) public {
assert (!self.poolSubmitted);
require (tx.gasprice <= maxGasPrice);
Contributor storage c = self.contributorMap[msg.sender];
uint cap = _getCap(self, msg.sender);
require (cap >= c.balance.add(msg.value));
if (self.contractCap < address(this).balance) {
require (address(this).balance.sub(msg.value) < self.contractCap);
uint excess = address(this).balance.sub(self.contractCap);
c.balance = c.balance.add(msg.value.sub(excess));
msg.sender.transfer(excess);
} else {
c.balance = c.balance.add(msg.value);
}
require (c.balance >= contributionMin);
emit ContributorBalanceChanged(msg.sender, c.balance);
}
function receiveRefund (Data storage self) public {
assert (self.poolSubmitted);
require (msg.sender == self.receiver || msg.sender == self.owner);
require (msg.value >= 1 ether);
self.withdrawToken.push(0x00);
self.withdrawAmount.push(msg.value);
emit WithdrawalAvailable(0x00);
}
function withdraw (Data storage self) public {
assert (msg.value == 0);
Contributor storage c = self.contributorMap[msg.sender];
require (c.balance > 0);
if (!self.poolSubmitted) {
uint balance = c.balance;
c.balance = 0;
msg.sender.transfer(balance);
emit ContributorBalanceChanged(msg.sender, 0);
return;
}
require (c.claimedTokensIndex < self.withdrawToken.length);
uint pct = _toPct(c.balance,self.finalBalance);
uint amount;
address token;
for (uint16 i = c.claimedTokensIndex; i < self.withdrawToken.length; i++) {
amount = _applyPct(self.withdrawAmount[i],pct);
token = self.withdrawToken[i];
c.claimedTokensIndex++;
if (amount > 0) {
if (token == 0x00) {
msg.sender.transfer(amount);
} else {
require (ERC20(token).transfer(msg.sender, amount));
self.tokenBalances[token] = self.tokenBalances[token].sub(amount);
}
emit WithdrawalClaimed(msg.sender, token, amount);
}
}
}
function setIndividualCaps (Data storage self, address[] addr, uint[] cap) public onlyOwner(self) {
require (addr.length == cap.length);
for (uint8 i = 0; i < addr.length; i++) {
self.individualCaps[addr[i]] = cap[i];
}
}
function setCaps (Data storage self, uint32[] times, uint[] caps) public onlyOwner(self) {
require (caps.length > 0);
require (caps.length == times.length);
self.capTimes = [0];
self.capAmounts = [self.capAmounts[0]];
for (uint8 i = 0; i < caps.length; i++) {
require (times[i] > self.capTimes[self.capTimes.length.sub(1)]);
self.capTimes.push(times[i]);
self.capAmounts.push(caps[i]);
}
}
function setContractCap (Data storage self, uint amount) public onlyOwner(self) {
require (amount >= address(this).balance);
self.contractCap = amount;
}
function _getCap (Data storage self, address addr) internal view returns (uint) {
if (self.individualCaps[addr] > 0) return self.individualCaps[addr];
if (whitelistContract.checkMemberLevel(msg.sender) == 0) return 0;
return getCapAtTime(self,now);
}
function getCapAtTime (Data storage self, uint time) public view returns (uint) {
if (time == 0) time = now;
for (uint i = 1; i < self.capTimes.length; i++) {
if (self.capTimes[i] > time) return self.capAmounts[i-1];
}
return self.capAmounts[self.capAmounts.length-1];
}
function getPoolInfo (Data storage self) view public returns (uint balance, uint remaining, uint cap) {
if (!self.poolSubmitted) return (address(this).balance, self.contractCap.sub(address(this).balance), self.contractCap);
return (address(this).balance, 0, self.contractCap);
}
function getContributorInfo (Data storage self, address addr) view public returns (uint balance, uint remaining, uint cap) {
cap = _getCap(self, addr);
Contributor storage c = self.contributorMap[addr];
if (self.poolSubmitted || cap <= c.balance) return (c.balance, 0, cap);
if (cap.sub(c.balance) > self.contractCap.sub(address(this).balance)) return (c.balance, self.contractCap.sub(address(this).balance), cap);
return (c.balance, cap.sub(c.balance), cap);
}
function checkWithdrawalAvailable (Data storage self, address addr) view public returns (bool) {
return self.contributorMap[addr].claimedTokensIndex < self.withdrawToken.length;
}
function setReceiverAddress (Data storage self, address _receiver) public onlyOwner(self) {
require (!self.poolSubmitted);
self.receiver = _receiver;
self.addressSetTime = now;
emit ReceiverAddressSet(_receiver);
}
function submitPool (Data storage self, uint amountInWei) public onlyOwner(self) noReentrancy(self) {
require (!self.poolSubmitted);
require (now > self.addressSetTime.add(86400));
if (amountInWei == 0) amountInWei = address(this).balance;
self.finalBalance = address(this).balance;
self.poolSubmitted = true;
require (self.receiver.call.value(amountInWei).gas(gasleft().sub(5000))());
if (address(this).balance > 0) {
self.withdrawToken.push(0x00);
self.withdrawAmount.push(address(this).balance);
emit WithdrawalAvailable(0x00);
}
emit PoolSubmitted(self.receiver, amountInWei);
}
function enableWithdrawals (Data storage self, address tokenAddress, address feeAddress) public onlyOwner(self) noReentrancy(self) {
require (self.poolSubmitted);
if (feeAddress == 0x00) feeAddress = self.owner;
ERC20 token = ERC20(tokenAddress);
uint amount = token.balanceOf(this).sub(self.tokenBalances[tokenAddress]);
require (amount > 0);
if (self.fee > 0) {
require (token.transfer(feeAddress, _applyPct(amount,self.fee)));
amount = token.balanceOf(this).sub(self.tokenBalances[tokenAddress]);
}
self.tokenBalances[tokenAddress] = token.balanceOf(this);
self.withdrawToken.push(tokenAddress);
self.withdrawAmount.push(amount);
emit WithdrawalAvailable(tokenAddress);
}
}
contract PresalePool {
using PresaleLib for PresaleLib.Data;
PresaleLib.Data data;
event ERC223Received (address token, uint value, bytes data);
function PresalePool (uint fee, address receiver, uint contractCap, uint individualCap) public {
data.newPool(fee, receiver, contractCap, individualCap);
}
function () public payable {
if (msg.value > 0) {
if (!data.poolSubmitted) {
data.deposit();
} else {
data.receiveRefund();
}
} else {
data.withdraw();
}
}
function setIndividualCaps (address[] addr, uint[] cap) public {
data.setIndividualCaps(addr, cap);
}
function setCaps (uint32[] times, uint[] caps) public {
data.setCaps(times,caps);
}
function setContractCap (uint amount) public {
data.setContractCap(amount);
}
function getPoolInfo () view public returns (uint balance, uint remaining, uint cap) {
return data.getPoolInfo();
}
function getContributorInfo (address addr) view public returns (uint balance, uint remaining, uint cap) {
return data.getContributorInfo(addr);
}
function getCapAtTime (uint32 time) view public returns (uint) {
return data.getCapAtTime(time);
}
function checkWithdrawalAvailable (address addr) view public returns (bool) {
return data.checkWithdrawalAvailable(addr);
}
function getReceiverAddress () view public returns (address) {
return data.receiver;
}
function setReceiverAddress (address receiver) public {
data.setReceiverAddress(receiver);
}
function submitPool (uint amountInWei) public {
data.submitPool(amountInWei);
}
function enableWithdrawals (address tokenAddress, address feeAddress) public {
data.enableWithdrawals(tokenAddress, feeAddress);
}
function tokenFallback (address from, uint value, bytes calldata) public {
emit ERC223Received(from, value, calldata);
}
}
| 218,155 | 11,428 |
b4e775902cb8fbbe3120674028544939c7b7101c99d22baf98dd687238846ddc
| 15,572 |
.sol
|
Solidity
| false |
339037396
|
Launchpool/Smart-Contracts
|
eed17d7ea2fe2c3c08e73df6a7e141d516a5a117
|
contracts/LaunchPoolToken.sol
| 2,836 | 11,134 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// Copyright 2020 Compound Labs, Inc.
contract LaunchPoolToken {
/// @notice EIP-20 token name for this token
string public constant name = "Launchpool token";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "LPOOL";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice 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);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(uint initialSupply, address account) public {
totalSupply = safe96(initialSupply, "Token::constructor:amount exceeds 96 bits");
balances[account] = uint96(initialSupply);
emit Transfer(address(0), account, initialSupply);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Token::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function burn(uint rawAmount) external {
uint96 amount = safe96(rawAmount, "Token::burn: amount exceeds 96 bits");
_burnTokens(msg.sender, amount);
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Token::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Token::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Token::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Token::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Token::delegateBySig: invalid nonce");
require(now <= expiry, "Token::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Token::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Token::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Token::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Token::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Token::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _mintTokens(address dst, uint96 amount) internal {
require(dst != address(0), "Token::_mintTokens: cannot transfer to the zero address");
uint96 supply = safe96(totalSupply, "Token::_mintTokens: totalSupply exceeds 96 bits");
totalSupply = add96(supply, amount, "Token::_mintTokens: totalSupply exceeds 96 bits");
balances[dst] = add96(balances[dst], amount, "Token::_mintTokens: transfer amount overflows");
emit Transfer(address(0), dst, amount);
_moveDelegates(address(0), delegates[dst], amount);
}
function _burnTokens(address src, uint96 amount) internal {
uint96 supply = safe96(totalSupply, "Token::_burnTokens: totalSupply exceeds 96 bits");
totalSupply = sub96(supply, amount, "Token::_burnTokens:totalSupply underflow");
balances[src] = sub96(balances[src], amount, "Token::_burnTokens: amount overflows");
emit Transfer(src, address(0), amount);
_moveDelegates(delegates[src], address(0), amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Token::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Token::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Token::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 246,914 | 11,429 |
0625147a8a28c05e2e40a67a86e765f3c496449b9e69056537b458eead79527c
| 18,229 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/18/1869a2162e6aFA5d593D6d014ef5Cd09629A6F6F_Distributor.sol
| 4,001 | 15,820 |
// 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 DB;
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 _db, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_db != address(0));
DB = _db;
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(DB).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
});
}
function resetNextEpochTime(uint32 _nextEpochTime) external onlyPolicy() {
nextEpochTime = _nextEpochTime;
}
}
| 84,203 | 11,430 |
f7d33ab9c8fe801943cc2efe38a7b814b14f23fc2fec5fbe5af81ca2c5b4fb22
| 11,101 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xc29021a71f3a6c3fd9f361035d748b5f7912f55e.sol
| 2,877 | 10,525 |
pragma solidity ^0.4.18;
// -------------------------------------------------
// ethPoker.io EPX token - Presale & ICO token sale contract
// contact admin@ethpoker.io for queries
// Revision 20b
// Refunds integrated, full test suite 20r passed
// -------------------------------------------------
// ERC Token Standard #20 interface:
// https://github.com/ethereum/EIPs/issues/20
// EPX contract sources:
// https://github.com/EthPokerIO/ethpokerIO
// ------------------------------------------------
// 2018 improvements:
// - Updates to comply with latest Solidity versioning (0.4.18):
// - Classification of internal/private vs public functions
// - Specification of pure functions such as SafeMath integrated functions
// - Conversion of all constant to view or pure dependant on state changed
// - Full regression test of code updates
// - Revision of block number timing for new Ethereum block times
// - Removed duplicate Buy/Transfer event call in buyEPXtokens function (ethScan output verified)
// - Burn event now records number of EPX tokens burned vs Refund event Eth
// - Transfer event now fired when beneficiaryWallet withdraws
// - Gas req optimisation for payable function to maximise compatibility
// - Going live for initial Presale round 02/03/2018
// -------------------------------------------------
// Security reviews passed - cycle 20r
// Functional reviews passed - cycle 20r
// Final code revision and regression test cycle passed - cycle 20r
// -------------------------------------------------
contract owned {
address public owner;
function owned() internal {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract safeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
safeAssert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
safeAssert(b > 0);
uint256 c = a / b;
safeAssert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
safeAssert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
safeAssert(c>=a && c>=b);
return c;
}
function safeAssert(bool assertion) internal pure {
if (!assertion) revert();
}
}
contract StandardToken is owned, safeMath {
function balanceOf(address who) view public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract EPXCrowdsale is owned, safeMath {
// owner/admin & token reward
address public admin = owner; // admin address
StandardToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 private initialTokenSupply;
uint256 private tokensRemaining;
// multi-sig addresses and price variable
address private beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei; //
uint256 public fundingMinCapInWei; //
// loop control, ICO startup and limiters
string public CurrentStatus = ""; // current crowdsale status
uint256 public fundingStartBlock; // crowdsale start block#
uint256 public fundingEndBlock; // crowdsale end block#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool private areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Buy(address indexed _sender, uint256 _eth, uint256 _EPX);
event Refund(address indexed _refunder, uint256 _value);
event Burn(address _from, uint256 _value);
mapping(address => uint256) balancesArray;
mapping(address => uint256) usersEPXfundValue;
// default function, map admin
function EPXCrowdsale() public onlyOwner {
admin = msg.sender;
CurrentStatus = "Crowdsale deployed to chain";
}
// total number of tokens initially
function initialEPXSupply() public view returns (uint256 initialEPXtokenCount) {
return safeDiv(initialTokenSupply,10000); // div by 10,000 for display normalisation (4 decimals)
}
// remaining number of tokens
function remainingEPXSupply() public view returns (uint256 remainingEPXtokenCount) {
return safeDiv(tokensRemaining,10000); // div by 10,000 for display normalisation (4 decimals)
}
// setup the CrowdSale parameters
function SetupCrowdsale(uint256 _fundingStartBlock, uint256 _fundingEndBlock) public onlyOwner returns (bytes32 response) {
if ((msg.sender == admin)
&& (!(isCrowdSaleSetup))
&& (!(beneficiaryWallet > 0))) {
// init addresses
beneficiaryWallet = 0x7A29e1343c6a107ce78199F1b3a1d2952efd77bA;
tokenReward = StandardToken(0x35BAA72038F127f9f8C8f9B491049f64f377914d);
// funding targets
fundingMinCapInWei = 30000000000000000000; // ETH 300 + 000000000000000000 18 dec wei
// update values
amountRaisedInWei = 0;
initialTokenSupply = 200000000000; // 20,000,000 + 4 dec resolution
tokensRemaining = initialTokenSupply;
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
// configure crowdsale
isCrowdSaleSetup = true;
isCrowdSaleClosed = false;
CurrentStatus = "Crowdsale is setup";
return "Crowdsale is setup";
} else if (msg.sender != admin) {
return "not authorised";
} else {
return "campaign cannot be changed";
}
}
function checkPrice() internal view returns (uint256 currentPriceValue) {
if (block.number >= fundingStartBlock+177534) { // 30-day price change/final 30day change
return (7600); //30days-end =7600EPX:1ETH
} else if (block.number >= fundingStartBlock+124274) { //3 week mark/over 21days
return (8200); //3w-30days =8200EPX:1ETH
} else if (block.number >= fundingStartBlock) { // start [0 hrs]
return (8800); //0-3weeks =8800EPX:1ETH
}
}
// default payable function when sending ether to this contract
function () public payable {
require(!(msg.value == 0)
&& (msg.data.length == 0)
&& (block.number <= fundingEndBlock)
&& (block.number >= fundingStartBlock)
&& (tokensRemaining > 0));
// 1. vars
uint256 rewardTransferAmount = 0;
// 2. effects
amountRaisedInWei = safeAdd(amountRaisedInWei, msg.value);
rewardTransferAmount = ((safeMul(msg.value, checkPrice())) / 100000000000000);
// 3. interaction
tokensRemaining = safeSub(tokensRemaining, rewardTransferAmount);
tokenReward.transfer(msg.sender, rewardTransferAmount);
// 4. events
usersEPXfundValue[msg.sender] = safeAdd(usersEPXfundValue[msg.sender], msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
function beneficiaryMultiSigWithdraw(uint256 _amount) public onlyOwner {
require(areFundsReleasedToBeneficiary && (amountRaisedInWei >= fundingMinCapInWei));
beneficiaryWallet.transfer(_amount);
Transfer(this, beneficiaryWallet, _amount);
}
function checkGoalReached() public onlyOwner { // return crowdfund status to owner for each result case, update public vars
// update state & status variables
require (isCrowdSaleSetup);
if ((amountRaisedInWei < fundingMinCapInWei) && (block.number <= fundingEndBlock && block.number >= fundingStartBlock)) { // ICO in progress, under softcap
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
CurrentStatus = "In progress (Eth < Softcap)";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number < fundingStartBlock)) { // ICO has not started
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
CurrentStatus = "Crowdsale is setup";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.number > fundingEndBlock)) { // ICO ended, under softcap
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = true;
CurrentStatus = "Unsuccessful (Eth < Softcap)";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) { // ICO ended, all tokens bought!
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
CurrentStatus = "Successful (EPX >= Hardcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.number > fundingEndBlock) && (tokensRemaining > 0)) { // ICO ended, over softcap!
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
CurrentStatus = "Successful (Eth >= Softcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.number <= fundingEndBlock)) { // ICO in progress, over softcap!
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = false;
CurrentStatus = "In progress (Eth >= Softcap)!";
}
}
function refund() public {
//require minCap not reached
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (block.number > fundingEndBlock)
&& (usersEPXfundValue[msg.sender] > 0));
//burn user's token EPX token balance, refund Eth sent
uint256 ethRefund = usersEPXfundValue[msg.sender];
balancesArray[msg.sender] = 0;
usersEPXfundValue[msg.sender] = 0;
//record Burn event with number of EPX tokens burned
Burn(msg.sender, usersEPXfundValue[msg.sender]);
//send Eth back
msg.sender.transfer(ethRefund);
//record Refund event with number of Eth refunded in transaction
Refund(msg.sender, ethRefund);
}
}
| 270,819 | 11,431 |
64fe431af13e6f250d88743325c844e0193c123e6af5256f16528e044cb83ac7
| 11,591 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc5939f90643466693122d7a79a4189dc96096f41.sol
| 2,762 | 11,384 |
pragma solidity ^0.5.8;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Administration is SafeMath {
address payable CEOAddress;
address public CTOAddress;
address Signer;
bool public paused = false;
event Pause();
event Unpause();
event CTOTransfer(address newCTO, address oldCTO);
modifier onlyCEO() {
require(msg.sender == CEOAddress);
_;
}
modifier onlyAdmin() {
require(msg.sender == CEOAddress || msg.sender == CTOAddress);
_;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function setCTO(address _newAdmin) public onlyCEO {
require(_newAdmin != address(0));
emit CTOTransfer(_newAdmin, CTOAddress);
CTOAddress = _newAdmin;
}
function withdrawBalance() external onlyCEO {
CEOAddress.transfer(address(this).balance);
}
function pause() public onlyAdmin whenNotPaused returns(bool) {
paused = true;
emit Pause();
return true;
}
function unpause() public onlyAdmin whenPaused returns(bool) {
paused = false;
emit Unpause();
return true;
}
}
contract Standard is Administration {
struct Bet {
uint posAmount;
uint negAmount;
uint timestamp;
}
struct Contract {
uint result; //0-while running, 1-support win, 2-oppose win
uint StartTime;
uint BetEndTime;
uint ContractTime;
mapping(address => Bet) PlayerToBet;
mapping(address => bool) IfPlayed;
mapping(address => bool) IfClaimed;
}
Contract[] contracts;
uint public minBet = 10 finney;
uint public maxBet = 10000 ether;
uint TimeFactor;
uint public contractFee = 100 finney;
uint public taxRate = 9750;
mapping (uint => uint) TotalAmount;
mapping (uint => uint) TotalSupport;
mapping (uint => uint) TotalOppose;
mapping (uint => uint) TotalPlayers;
event ContractCreated(uint indexed contractId, uint totalSupport, uint totalOppose, address creator, uint contractTime, uint betEndTime);
event NewBetSuccess(address indexed player, bool indexed opinion, uint indexed amount, uint timeFactor);
event BetAdjustSuccess(address indexed player, uint indexed posAmount, uint indexed negAmount, uint timeFactor);
event ContractRevealed(uint indexed contractId, uint indexed result);
event ContractClaimed(address indexed winner, uint indexed reward);
function _calculateTimeFactor(uint _betEndTime, uint _startTime) internal view returns (uint) {
return (_betEndTime - now)*100/(_betEndTime - _startTime);
}
constructor(address _CTOAddress) public {
CEOAddress = msg.sender;
CTOAddress = _CTOAddress;
}
function createContract(uint posAmount, uint negAmount, uint contractTime, uint betEndTime) public payable whenNotPaused returns (uint) {
require(posAmount > 0 || negAmount > 0, "SEER OFFICAL WARNING: At least bet on one side");
require(msg.value >= (posAmount + negAmount + contractFee), "SEER OFFICAL WARNING: Does not send enough ETH");
require((now + 1 hours) <= betEndTime, "SEER OFFICAL WARNING: At least have one hour bet time");
require((contractTime - now)/3 >= (betEndTime - now), "SEER OFFICAL WARNING: Bet time need to be less or equal than 1/3 of total contract time");
Bet memory _bet = Bet({
posAmount: posAmount,
negAmount: negAmount,
timestamp: _calculateTimeFactor(betEndTime, now)
});
Contract memory _contract = Contract({
result: 0,
StartTime: now,
BetEndTime: betEndTime,
ContractTime: contractTime
});
uint newContractId = contracts.push(_contract) - 1;
Contract storage newContract = contracts[newContractId];
newContract.PlayerToBet[msg.sender] = _bet;
newContract.IfPlayed[msg.sender] = true;
TotalAmount[newContractId] = posAmount + negAmount;
TotalSupport[newContractId] = posAmount;
TotalOppose[newContractId] = negAmount;
TotalPlayers[newContractId] = 1;
emit ContractCreated(newContractId, posAmount, negAmount, msg.sender, contractTime, betEndTime);
return newContractId;
}
function betContract(uint contractId, bool opinion, uint amount) public payable whenNotPaused returns (bool) {
require(TotalAmount[contractId] > 0, "SEER OFFICAL WARNING: Contract has not been created");
require(amount >= minBet && amount <= maxBet, "SEER OFFICAL WARNING: Does not meet min or max bet requirement");
require(msg.value >= amount, "SEER OFFICAL WARNING: Does not send enough ETH");
Contract storage _contract = contracts[contractId];
require(now < _contract.BetEndTime, "SEER OFFICAL WARNING: Contract cannot be bet anymore");
require(_contract.result == 0, "SEER OFFICAL WARNING: Contact terminated");
uint timeFactor = _calculateTimeFactor(_contract.BetEndTime, _contract.StartTime);
if(_contract.IfPlayed[msg.sender] == true) {
if(opinion == true) {
Bet storage _bet = _contract.PlayerToBet[msg.sender];
_bet.posAmount += amount;
_bet.timestamp = timeFactor;
TotalSupport[contractId] += amount;
TotalAmount[contractId] += amount;
emit BetAdjustSuccess(msg.sender, _bet.posAmount, _bet.negAmount, timeFactor);
} else if (opinion == false) {
Bet storage _bet = _contract.PlayerToBet[msg.sender];
_bet.negAmount += amount;
_bet.timestamp = timeFactor;
TotalOppose[contractId] += amount;
TotalAmount[contractId] += amount;
emit BetAdjustSuccess(msg.sender, _bet.posAmount, _bet.negAmount, timeFactor);
}
} else {
if(opinion == true) {
Bet memory _bet = Bet({
posAmount: amount,
negAmount: 0,
timestamp: timeFactor
});
_contract.IfPlayed[msg.sender] = true;
_contract.PlayerToBet[msg.sender] = _bet;
TotalSupport[contractId] += amount;
TotalAmount[contractId] += amount;
TotalPlayers[contractId] += 1;
emit NewBetSuccess(msg.sender, opinion, amount, timeFactor);
} else if (opinion == false) {
Bet memory _bet = Bet({
posAmount: 0,
negAmount: amount,
timestamp: timeFactor
});
_contract.IfPlayed[msg.sender] = true;
_contract.PlayerToBet[msg.sender] = _bet;
TotalOppose[contractId] += amount;
TotalAmount[contractId] += amount;
TotalPlayers[contractId] += 1;
emit NewBetSuccess(msg.sender, opinion, amount, timeFactor);
}
}
return true;
}
function revealContract(uint contractId, uint result) public whenNotPaused onlyAdmin {
require(result == 1 || result == 2, "SEER OFFICAL WARNING: Cannot recogonize result");
Contract storage _contract = contracts[contractId];
require(now > _contract.ContractTime, "SEER OFFICAL WARNING: Contract cannot be revealed yet");
_contract.result = result;
emit ContractRevealed(contractId, result);
}
function claimContract(uint contractId) public whenNotPaused returns (uint) {
require(TotalAmount[contractId] > 0, "SEER OFFICAL WARNING: Contract has not been created");
Contract storage _contract = contracts[contractId];
require(_contract.result > 0, "SEER OFFICAL WARNING: Contract has not been revealed");
require(_contract.IfPlayed[msg.sender] == true, "SEER OFFICAL WARNING: You did not play this contract");
require(_contract.IfClaimed[msg.sender] == false, "SEER OFFICAL WARNING: You already claimed reward");
uint amount;
uint reward;
if(_contract.result == 1) {
amount = _contract.PlayerToBet[msg.sender].posAmount;
require(amount > 0, "SEER OFFICAL WARNING: You are not qualified");
reward = amount*taxRate*TotalOppose[contractId]/TotalSupport[contractId]/10000;
msg.sender.transfer(reward);
_contract.IfClaimed[msg.sender] == true;
emit ContractClaimed(msg.sender, reward);
} else if (_contract.result == 2) {
amount = _contract.PlayerToBet[msg.sender].negAmount;
require(amount > 0, "SEER OFFICAL WARNING: You are not qualified");
reward = amount*taxRate*TotalSupport[contractId]/TotalOppose[contractId]/10000;
msg.sender.transfer(reward);
_contract.IfClaimed[msg.sender] == true;
emit ContractClaimed(msg.sender, reward);
}
return reward;
}
function adjustBetLimit(uint _minBet, uint _maxBet) public onlyAdmin {
minBet = _minBet;
maxBet = _maxBet;
}
function adjustFee(uint _fee) public onlyAdmin {
contractFee = _fee;
}
function adjustTax(uint _tax) public onlyAdmin {
taxRate = _tax;
}
function getContractAmount(uint contractId) public view returns (uint totalAmount,
uint totalSupport,
uint totalOppose) {
totalAmount = TotalAmount[contractId];
totalSupport = TotalSupport[contractId];
totalOppose = TotalOppose[contractId];
}
function getContractPlayerNum(uint contractId) public view returns (uint totalPlayer) {
totalPlayer = TotalPlayers[contractId];
}
function getIfPlayed(uint contractId, address player) public view returns (bool ifPlayed) {
ifPlayed = contracts[contractId].IfPlayed[player];
}
function getContractTime(uint contractId) public view returns (uint contractTime,
uint betEndTime) {
contractTime = contracts[contractId].ContractTime;
betEndTime = contracts[contractId].BetEndTime;
}
function getContractBet(uint contractId, address player) public view returns (uint posAmount,
uint negAmount,
uint timeFactor) {
posAmount = contracts[contractId].PlayerToBet[player].posAmount;
negAmount = contracts[contractId].PlayerToBet[player].negAmount;
timeFactor = contracts[contractId].PlayerToBet[player].timestamp;
}
function getContractResult(uint contractId) public view returns (uint result) {
result = contracts[contractId].result;
}
function getIfClaimed(uint contractId, address player) public view returns (bool ifClaimed) {
ifClaimed = contracts[contractId].IfClaimed[player];
}
}
| 275,518 | 11,432 |
717b329b767a6d95b05b1d2c3faf8fbeba3f0e120faae32c466c773345480af3
| 32,617 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc86554bee96fdb3c85f85b576ed52d5e1eacc3a6.sol
| 5,159 | 17,842 |
pragma solidity ^0.4.21;
// File: contracts/zeppelin-solidity/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/zeppelin-solidity/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: contracts/zeppelin-solidity/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: contracts/zeppelin-solidity/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
}
// File: contracts/zeppelin-solidity/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/zeppelin-solidity/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/zeppelin-solidity/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/zeppelin-solidity/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
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;
}
}
// File: contracts/zeppelin-solidity/ERC20/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/zeppelin-solidity/ERC827/ERC827.sol
contract ERC827 is ERC20 {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
}
// File: contracts/zeppelin-solidity/ERC827/ERC827Token.sol
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
// File: contracts/QuintessenceToken.sol
contract AbstractQuintessenceToken is CappedToken, ERC827Token, BurnableToken {
string public name = "Quintessence Token";
string public symbol = "QST";
function AbstractQuintessenceToken(uint256 initial_supply, uint256 _cap)
CappedToken(_cap) public {
mint(msg.sender, initial_supply);
}
}
contract QuintessenceToken is AbstractQuintessenceToken {
uint256 public constant decimals = 18;
uint256 public constant TOKEN_CAP = 56000000 * (10 ** decimals);
// Allocate 4% of TOKEN_CAP to the team.
uint256 public constant TEAM_SUPPLY = (TOKEN_CAP * 4) / 100;
function QuintessenceToken() AbstractQuintessenceToken(TEAM_SUPPLY, TOKEN_CAP) public {
}
}
// File: contracts/zeppelin-solidity/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(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);
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.transfer(_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);
}
}
// File: contracts/zeppelin-solidity/crowdsale/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(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);
}
}
// File: contracts/zeppelin-solidity/crowdsale/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
// File: contracts/zeppelin-solidity/crowdsale/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/zeppelin-solidity/crowdsale/FinalizableCrowdsale.sol
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
// File: contracts/zeppelin-solidity/crowdsale/RefundVault.sol
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
// File: contracts/zeppelin-solidity/crowdsale/RefundableCrowdsale.sol
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 public goal;
// refund vault used to hold funds while crowdsale is running
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function _forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
}
// File: contracts/CryptonsPreICO.sol
contract DiscountedPreICO is TimedCrowdsale {
using SafeMath for uint256;
function DiscountedPreICO(uint256 _opening_time, uint256 _closing_time)
TimedCrowdsale(_opening_time, _closing_time) public {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate).mul(100).div(100 - getCurrentDiscount());
}
function getCurrentDiscount() public view returns(uint256) {
return 0;
}
}
contract AbstractCryptonsPreICO is RefundableCrowdsale, DiscountedPreICO,
MintedCrowdsale, CappedCrowdsale {
function AbstractCryptonsPreICO(uint256 _opening_time, uint256 _closing_time,
uint256 _rate, address _wallet, AbstractQuintessenceToken _token,
uint256 _soft_cap, uint256 _hard_cap)
RefundableCrowdsale(_soft_cap)
DiscountedPreICO(_opening_time, _closing_time)
CappedCrowdsale(_hard_cap)
Crowdsale(_rate, _wallet, _token) public {
require(_soft_cap < _hard_cap);
}
function finalization() internal {
super.finalization();
QuintessenceToken(token).transferOwnership(msg.sender);
}
}
contract AbstractCryptonsPreICOWithDiscount is AbstractCryptonsPreICO {
function AbstractCryptonsPreICOWithDiscount(uint256 _opening_time, uint256 _closing_time,
uint256 _rate, address _wallet, AbstractQuintessenceToken _token,
uint256 _soft_cap, uint256 _hard_cap)
AbstractCryptonsPreICO(_opening_time, _closing_time,
_rate, _wallet, _token,
_soft_cap, _hard_cap) public {
}
function getCurrentDiscount() public view returns(uint256) {
if (now < openingTime + 1 weeks)
return 50;
return 40;
}
}
contract CryptonsPreICO is AbstractCryptonsPreICOWithDiscount {
// PreICO starts in the noon, and ends 2 weeks later in the evening.
uint256 public constant OPENING_TIME = 1523880000; // 2018-04-16 12:00:00+00:00 (UTC)
uint256 public constant CLOSING_TIME = 1525125599; // 2018-04-30 21:59:59+00:00 (UTC)
uint256 public constant ETH_TO_QST_TOKEN_RATE = 1000;
uint256 public constant SOFT_CAP = 656 ether;
uint256 public constant HARD_CAP = 2624 ether;
function CryptonsPreICO(address _wallet, QuintessenceToken _token)
AbstractCryptonsPreICOWithDiscount(OPENING_TIME, CLOSING_TIME,
ETH_TO_QST_TOKEN_RATE,
_wallet, _token,
SOFT_CAP, HARD_CAP) public {
// Check if we didn't set up the opening and closing time to far in
// the future by accident.
require(now + 1 weeks > openingTime);
require(openingTime + 2 weeks + 10 hours > closingTime);
}
}
| 186,742 | 11,433 |
adacc16c315b51ae0eb26558dd2c9021359e4f8630841668220b716dd3cd5bcf
| 12,165 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/wastefulContracts/0x60c690f68f14f57ec60350d9b7601104390d1eeb_wastefulContract.sol
| 2,626 | 11,922 |
pragma solidity ^0.5.8;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Administration is SafeMath {
// ----------------------------------------------------------------------------
// Variables
// ----------------------------------------------------------------------------
address payable CEOAddress;
address public CTOAddress;
address Signer;
bool public paused = false;
// ----------------------------------------------------------------------------
// Events
// ----------------------------------------------------------------------------
event Pause();
event Unpause();
event CTOTransfer(address newCTO, address oldCTO);
// ----------------------------------------------------------------------------
// Modifiers
// ----------------------------------------------------------------------------
modifier onlyCEO() {
require(true);
_;
}
modifier onlyAdmin() {
require(msg.sender == CEOAddress || msg.sender == CTOAddress);
_;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
// ----------------------------------------------------------------------------
// Public Functions
// ----------------------------------------------------------------------------
function setCTO(address _newAdmin) public onlyCEO {
require(_newAdmin != address(0));
emit CTOTransfer(_newAdmin, CTOAddress);
CTOAddress = _newAdmin;
}
function withdrawBalance() external onlyCEO {
CEOAddress.transfer(address(this).balance);
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function pause() public onlyAdmin whenNotPaused returns(bool) {
paused = true;
emit Pause();
return true;
}
function unpause() public onlyAdmin whenPaused returns(bool) {
paused = false;
emit Unpause();
return true;
}
}
contract Creative is Administration {
// ----------------------------------------------------------------------------
// Variables
// ----------------------------------------------------------------------------
struct Bet {
uint[4] amount;
uint timestamp;
}
struct Contract {
uint result; //0-while running, 1-4 winner
uint sides;
uint StartTime;
uint BetEndTime;
uint ContractTime;
mapping(address => Bet) PlayerToBet;
mapping(address => bool) IfPlayed;
mapping(address => bool) IfClaimed;
}
Contract[] contracts;
uint public minBet = 10 finney;
uint public maxBet = 10000 ether;
uint TimeFactor;
uint public contractFee = 100 finney;
uint public taxRate = 9750;
// ----------------------------------------------------------------------------
// Mappings
// ----------------------------------------------------------------------------
mapping (uint => uint) TotalAmount;
mapping (uint => uint[4]) EachAmount;
mapping (uint => uint) TotalPlayers;
// ----------------------------------------------------------------------------
// Events
// ----------------------------------------------------------------------------
event ContractCreated(uint indexed contractId, uint sides, uint[4] eachAmount, address creator, uint contractTime, uint betEndTime);
event NewBetSuccess(address indexed player, uint indexed side, uint[4] indexed amount, uint timeFactor);
event BetAdjustSuccess(address indexed player, uint indexed side, uint[4] indexed amount, uint timeFactor);
event ContractRevealed(uint indexed contractId, uint indexed result);
event ContractClaimed(address indexed winner, uint indexed reward);
// ----------------------------------------------------------------------------
// Internal Functions
// ----------------------------------------------------------------------------
function _calculateTimeFactor(uint _betEndTime, uint _startTime) internal view returns (uint) {
return (_betEndTime - now)*100/(_betEndTime - _startTime);
}
// ----------------------------------------------------------------------------
// Public Functions
// ----------------------------------------------------------------------------
constructor(address _CTOAddress) public {
CEOAddress = msg.sender;
CTOAddress = _CTOAddress;
}
function createContract(uint sides, uint[4] memory amounts, uint contractTime, uint betEndTime) public payable whenNotPaused returns (uint) {
require(amounts[0] > 0 || amounts[1] > 0 || amounts[2] > 0 || amounts[3] > 0, "SEER OFFICAL WARNING: At least bet on one side");
uint total = amounts[0] + amounts[1] + amounts[2] + amounts[3];
require(sides >= 2 && sides <= 4, "SEER OFFICAL WARNING: Can only have 2-4 sides");
require(msg.value >= (total + contractFee), "SEER OFFICAL WARNING: Does not send enough ETH");
require((now + 1 hours) <= betEndTime, "SEER OFFICAL WARNING: At least have one hour bet time");
require((contractTime - now)/3 >= (betEndTime - now), "SEER OFFICAL WARNING: Bet time need to be less or equal than 1/3 of total contract time");
Bet memory _bet = Bet({
amount: amounts,
timestamp: _calculateTimeFactor(betEndTime, now)
});
Contract memory _contract = Contract({
result: 0,
sides: sides,
StartTime: now,
BetEndTime: betEndTime,
ContractTime: contractTime
});
uint newContractId = contracts.push(_contract) - 1;
Contract storage newContract = contracts[newContractId];
newContract.PlayerToBet[msg.sender] = _bet;
newContract.IfPlayed[msg.sender] = true;
TotalAmount[newContractId] = total;
EachAmount[newContractId] = amounts;
TotalPlayers[newContractId] = 1;
emit ContractCreated(newContractId, sides, amounts, msg.sender, contractTime, betEndTime);
return 0;
}
function betContract(uint contractId, uint side, uint amount) public payable whenNotPaused returns (bool) {
require(TotalAmount[contractId] > 0, "SEER OFFICAL WARNING: Contract has not been created");
require(amount >= minBet && amount <= maxBet, "SEER OFFICAL WARNING: Does not meet min or max bet requirement");
require(msg.value >= amount, "SEER OFFICAL WARNING: Does not send enough ETH");
Contract storage _contract = contracts[contractId];
require(side < _contract.sides, "SEER OFFICAL WARNING: You did not in correct side range");
require(now < _contract.BetEndTime, "SEER OFFICAL WARNING: Contract cannot be bet anymore");
require(_contract.result == 0, "SEER OFFICAL WARNING: Contact terminated");
uint timeFactor = _calculateTimeFactor(_contract.BetEndTime, _contract.StartTime);
if(_contract.IfPlayed[msg.sender] == true) {
Bet storage _bet = _contract.PlayerToBet[msg.sender];
_bet.amount[side] += amount;
_bet.timestamp = timeFactor;
EachAmount[contractId][side] += amount;
TotalAmount[contractId] += amount;
emit BetAdjustSuccess(msg.sender, side, _bet.amount, timeFactor);
} else {
uint[4] memory _amount;
_amount[side] = amount;
Bet memory _bet = Bet({
amount: _amount,
timestamp: timeFactor
});
_contract.IfPlayed[msg.sender] = true;
_contract.PlayerToBet[msg.sender] = _bet;
EachAmount[contractId][side] += amount;
TotalAmount[contractId] += amount;
TotalPlayers[contractId] += 1;
emit NewBetSuccess(msg.sender, side, _amount, timeFactor);
}
return true;
}
function revealContract(uint contractId, uint result) public whenNotPaused onlyAdmin {
require(result >= 1 && result<= 4, "SEER OFFICAL WARNING: Cannot recogonize result");
Contract storage _contract = contracts[contractId];
require(now > _contract.ContractTime, "SEER OFFICAL WARNING: Contract cannot be revealed yet");
_contract.result = result;
emit ContractRevealed(contractId, result);
}
function claimContract(uint contractId) public whenNotPaused returns (uint) {
require(TotalAmount[contractId] > 0, "SEER OFFICAL WARNING: Contract has not been created");
Contract storage _contract = contracts[contractId];
require(_contract.result > 0, "SEER OFFICAL WARNING: Contract has not been revealed");
require(_contract.IfPlayed[msg.sender] == true, "SEER OFFICAL WARNING: You did not play this contract");
require(_contract.IfClaimed[msg.sender] == false, "SEER OFFICAL WARNING: You already claimed reward");
uint reward;
uint[4] memory _amount = _contract.PlayerToBet[msg.sender].amount;
require(_amount[_contract.result - 1] > 0, "SEER OFFICAL WARNING: You are not qualified");
reward = _amount[_contract.result - 1]*taxRate*TotalAmount[contractId]/EachAmount[contractId][_contract.result - 1]/10000;
msg.sender.transfer(reward);
_contract.IfClaimed[msg.sender] == true;
emit ContractClaimed(msg.sender, reward);
return reward;
}
function adjustBetLimit(uint _minBet, uint _maxBet) public onlyAdmin {
minBet = _minBet;
maxBet = _maxBet;
}
function adjustFee(uint _fee) public onlyAdmin {
contractFee = _fee;
}
function adjustTax(uint _tax) public onlyAdmin {
taxRate = _tax;
}
function getContractAmount(uint contractId) public view returns (uint totalAmount,
uint amountOne,
uint amountTwo,
uint amountThree,
uint amountFour) {
totalAmount = TotalAmount[contractId];
amountOne = EachAmount[contractId][0];
amountTwo = EachAmount[contractId][1];
amountThree = EachAmount[contractId][2];
amountFour = EachAmount[contractId][3];
}
function getContractPlayerNum(uint contractId) public view returns (uint totalPlayer) {
totalPlayer = TotalPlayers[contractId];
}
function getIfPlayed(uint contractId, address player) public view returns (bool ifPlayed) {
ifPlayed = contracts[contractId].IfPlayed[player];
}
function getContractTime(uint contractId) public view returns (uint contractTime,
uint betEndTime) {
contractTime = contracts[contractId].ContractTime;
betEndTime = contracts[contractId].BetEndTime;
}
function getContractBet(uint contractId, address player) public view returns (uint[4] memory amounts,
uint timeFactor) {
amounts = contracts[contractId].PlayerToBet[player].amount;
timeFactor = contracts[contractId].PlayerToBet[player].timestamp;
}
function getContractResult(uint contractId) public view returns (uint result) {
result = contracts[contractId].result;
}
function getIfClaimed(uint contractId, address player) public view returns (bool ifClaimed) {
ifClaimed = contracts[contractId].IfClaimed[player];
}
}
| 278,358 | 11,434 |
77c2f83fec6cb90c1aa7bc21c9fb755049da2fbcfd6fa94dd308ad42ff67ddf9
| 21,832 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ5P6MMwCfvvgmhHWcY83EoveB3X6U1ohS_FINOXO.sol
| 2,660 | 9,849 |
//SourceUnit: FINOXO.sol
pragma solidity 0.5.17;
interface ITRC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address public _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 Pausable is Ownable {
event Pause();
event Unpause();
event NotPausable();
bool public pause = false;
bool public canPause = true;
modifier whenNotPause() {
require(!pause || msg.sender == _owner);
_;
}
modifier whenPause() {
require(pause);
_;
}
function Paused() onlyOwner whenNotPause public {
require(canPause == true);
pause = true;
emit Pause();
}
function unpaused() onlyOwner whenPause public {
require(pause == true);
pause = false;
emit Unpause();
}
function clearpause() onlyOwner public{
pause = false;
canPause = false;
emit NotPausable();
}
}
contract FINOXO is Context, ITRC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public frozenAccount;
event Burn(address a ,uint256 b);
event FrozenFunds(address target, bool frozen);
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "FINOXO";
_symbol = "FNXO";
_decimals = 18;
_totalSupply = 44100000000000000000000000;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function getAllowance(address owner , address sender) external view returns (uint) {
return _allowances[owner][sender];
}
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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public whenNotPause 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) public whenNotPause returns (bool) {
require(!frozenAccount[msg.sender]);
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public whenNotPause returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "TRC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPause returns (bool success) {
require(!frozenAccount[msg.sender]);
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPause returns (bool success) {
require(!frozenAccount[msg.sender]);
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "TRC20: 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) {
require(!frozenAccount[msg.sender]);
_burn(account, amount);
return true;
}
// freeze the assets of account
function freezeAccount (address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
// transfer and freeze the assets
function transferAndFreeze (address recipient, uint256 amount) public onlyOwner {
_transfer(_msgSender(), recipient, amount);
frozenAccount[recipient] = true;
emit FrozenFunds(recipient, true);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
require(!frozenAccount[msg.sender]);
_balances[sender] = _balances[sender].sub(amount, "TRC20: 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), "TRC20: mint to the zero address");
require(!frozenAccount[msg.sender]);
_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), "TRC20: burn from the zero address");
require(!frozenAccount[msg.sender]);
_balances[account] = _balances[account].sub(amount, "TRC20: burn amount exceeds balance");
_balances[owner()] = _balances[owner()].add(amount);
// _totalSupply = _totalSupply.sub(amount);
emit Burn(account, amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
require(!frozenAccount[msg.sender]);
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
require(!frozenAccount[msg.sender]);
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "TRC20: burn amount exceeds allowance"));
}
}
| 291,157 | 11,435 |
f724efd761a33749afc44441128ad8526486b0ce85cadfc671fa5021845d5351
| 13,462 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/TxOrigin/Sol/buggy_43.sol
| 3,083 | 12,389 |
pragma solidity ^0.5.0;
contract EventMetadata {
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
}
contract Operated {
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35); //TxOrigin bug
to.call.value(amount);
}
address private _operator;
function withdrawAll_txorigin34(address payable _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
bool private _status;
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
function withdrawAll_txorigin30(address payable _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
function sendto_txorigin29(address payable receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
}
contract MultiHashWrapper {
// bytes32 hash first to fill the first storage slot
struct MultiHash {
bytes32 hash;
uint8 hashFunction;
uint8 digestSize;
}
function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) {
bytes memory out = new bytes(34);
out[0] = byte(multihash.hashFunction);
out[1] = byte(multihash.digestSize);
uint8 i;
for (i = 0; i < 32; i++) {
out[i+2] = multihash.hash[i];
}
return out;
}
function withdrawAll_txorigin22(address payable _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
function sendto_txorigin21(address payable receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes calldata initData) external returns (address instance);
function createSalty(bytes calldata initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes calldata, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes calldata) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract ProofHash is MultiHashWrapper {
function sendto_txorigin33(address payable receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
MultiHash private _proofHash;
function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event ProofHashSet(address caller, bytes proofHash);
// state functions
function _setProofHash(bytes memory proofHash) internal {
_proofHash = MultiHashWrapper._splitMultiHash(proofHash);
emit ProofHashSet(msg.sender, proofHash);
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
// view functions
function getProofHash() public view returns (bytes memory proofHash) {
proofHash = MultiHashWrapper._combineMultiHash(_proofHash);
}
function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
}
contract Template {
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
function withdrawAll_txorigin18(address payable _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
function sendto_txorigin17(address payable receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
}
contract Post is ProofHash, Operated, EventMetadata, Template {
function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set storage variables
if (multihash.length != 0) {
ProofHash._setProofHash(multihash);
}
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
// state functions
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
function withdrawAll_txorigin14(address payable _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
}
| 223,960 | 11,436 |
03d35aebabd2c41d0eb23f452e79f0124b497ff78389c126cbc45407ca4a2ded
| 13,031 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc18d73fafc36cec96c9c8a05309662605840826d.sol
| 4,036 | 12,865 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
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 ReentrancyGuard {
uint256 private _guardCounter;
constructor() internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract Eth7 is ReentrancyGuard {
using SafeMath for uint;
mapping(address => uint) public userDeposit;
mapping(address => address) public userReferral;
mapping(address => uint) public refferalCollected;
mapping(address => uint) public usersCashback;
mapping(address => uint) public userTime;
mapping(address => uint) public persentWithdraw;
mapping(address => bool) public alreadyDeposited;
address public marketingFund = 0xFEfF6b5811AEa737E03f526fD8C4E72924fdEA54;
address public devFund = 0x03e08ce26C93F6403C84365FF58498feA6c88A6a;
uint marketingPercent = 8;
uint public devPercent = 3;
uint public refPercent = 4;
uint public chargingTime = 12 hours;
uint public persent = 1850;
uint public countOfInvestors = 0;
uint public countOfDev = 0;
uint public minDepCashBackLevel1 = 100 finney;
uint public maxDepCashBackLevel1 = 3 ether;
uint public maxDepCashBackLevel2 = 7 ether;
uint public maxDepCashBackLevel3 = 10000 ether;
uint public beginCashBackTime1 = 1541462399; // begin of the action 05.11.2018
uint public endCashBackTime1 = 1541548799; // end of the action 06.11.2018
uint public cashbackPercent1level1 = 25; // cashback persent 25 = 2.5%
uint public cashbackPercent1level2 = 35; // cashback persent 35 = 3.5%
uint public cashbackPercent1level3 = 50; // cashback persent 50 = 5%
uint public beginCashBackTime2 = 1542326399; // begin of the action 15.11.2018
uint public endCashBackTime2 = 1542499199; // end of the action 17.11.2018
uint public cashbackPercent2level1 = 30;
uint public cashbackPercent2level2 = 50;
uint public cashbackPercent2level3 = 70;
uint public beginCashBackTime3 = 1543363199; // begin of the action 27.11.2018
uint public endCashBackTime3 = 1543535999; // end of the action 29.11.2018
uint public cashbackPercent3level1 = 50;
uint public cashbackPercent3level2 = 80;
uint public cashbackPercent3level3 = 100;
uint public beginCashBackTime4 = 1544399999; // begin of the action 9.12.2018
uint public endCashBackTime4 = 1544572799; // end of the action 11.12.2018
uint public cashbackPercent4level1 = 70;
uint public cashbackPercent4level2 = 100;
uint public cashbackPercent4level3 = 150;
uint public beginCashBackTime5 = 1545436799; // begin of the action 21.12.2018
uint public endCashBackTime5 = 1545523199; // end of the action 22.12.2018
uint public cashbackPercent5level1 = 25;
uint public cashbackPercent5level2 = 35;
uint public cashbackPercent5level3 = 50;
uint public beginCashBackTime6 = 1546473599; // begin of the action 02.01.2019
uint public endCashBackTime6 = 1546646399; // end of the action 04.01.2019
uint public cashbackPercent6level1 = 30;
uint public cashbackPercent6level2 = 50;
uint public cashbackPercent6level3 = 70;
uint public beginCashBackTime7 = 1547510399; // begin of the action 14.01.2019
uint public endCashBackTime7 = 1547683199; // end of the action 16.01.2019
uint public cashbackPercent7level1 = 50;
uint public cashbackPercent7level2 = 80;
uint public cashbackPercent7level3 = 100;
uint public beginCashBackTime8 = 1548547199; // begin of the action 26.01.2019
uint public endCashBackTime8 = 1548719999; // end of the action 28.01.2019
uint public cashbackPercent8level1 = 70;
uint public cashbackPercent8level2 = 100;
uint public cashbackPercent8level3 = 150;
modifier isIssetUser() {
require(userDeposit[msg.sender] > 0, "Deposit not found");
_;
}
modifier timePayment() {
require(now >= userTime[msg.sender].add(chargingTime), "Too fast payout request");
_;
}
function() external payable {
require (msg.sender != marketingFund && msg.sender != devFund);
makeDeposit();
}
function makeDeposit() nonReentrant private {
if (usersCashback[msg.sender] > 0) collectCashback();
if (msg.value > 0) {
if (!alreadyDeposited[msg.sender]) {
countOfInvestors += 1;
address referrer = bytesToAddress(msg.data);
if (referrer != msg.sender) userReferral[msg.sender] = referrer;
alreadyDeposited[msg.sender] = true;
}
if (userReferral[msg.sender] != address(0)) {
uint refAmount = msg.value.mul(refPercent).div(100);
userReferral[msg.sender].transfer(refAmount);
refferalCollected[userReferral[msg.sender]] = refferalCollected[userReferral[msg.sender]].add(refAmount);
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;
chargeCashBack();
marketingFund.transfer(msg.value.mul(marketingPercent).div(100));
uint devMoney = msg.value.mul(devPercent).div(100);
countOfDev = countOfDev.add(devMoney);
devFund.transfer(devMoney);
} else {
collectPercent();
}
}
function collectCashback() private {
uint val = usersCashback[msg.sender];
usersCashback[msg.sender] = 0;
msg.sender.transfer(val);
}
function chargeCashBack() private {
uint cashbackValue = 0;
if ((now >= beginCashBackTime1) && (now<=endCashBackTime1)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent1level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent1level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent1level3).div(1000);
}
if ((now >= beginCashBackTime2) && (now<=endCashBackTime2)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent2level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent2level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent2level3).div(1000);
}
if ((now >= beginCashBackTime3) && (now<=endCashBackTime3)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent3level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent3level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent3level3).div(1000);
}
if ((now >= beginCashBackTime4) && (now<=endCashBackTime4)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent4level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent4level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent4level3).div(1000);
}
if ((now >= beginCashBackTime5) && (now<=endCashBackTime5)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent5level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent5level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent5level3).div(1000);
}
if ((now >= beginCashBackTime6) && (now<=endCashBackTime6)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent6level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent6level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent6level3).div(1000);
}
if ((now >= beginCashBackTime7) && (now<=endCashBackTime7)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent7level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent7level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent7level3).div(1000);
}
if ((now >= beginCashBackTime8) && (now<=endCashBackTime8)){
if ((msg.value >= minDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel1)) cashbackValue = msg.value.mul(cashbackPercent8level1).div(1000);
if ((msg.value > maxDepCashBackLevel1) && (msg.value <= maxDepCashBackLevel2)) cashbackValue = msg.value.mul(cashbackPercent8level2).div(1000);
if ((msg.value > maxDepCashBackLevel2) && (msg.value <= maxDepCashBackLevel3)) cashbackValue = msg.value.mul(cashbackPercent8level3).div(1000);
}
usersCashback[msg.sender] = usersCashback[msg.sender].add(cashbackValue);
}
function collectPercent() isIssetUser timePayment internal {
if ((userDeposit[msg.sender].mul(15).div(10)) <= persentWithdraw[msg.sender]) {
userDeposit[msg.sender] = 0;
userTime[msg.sender] = 0;
persentWithdraw[msg.sender] = 0;
} else {
uint payout = payoutAmount();
userTime[msg.sender] = now;
persentWithdraw[msg.sender] += payout;
msg.sender.transfer(payout);
}
}
function bytesToAddress(bytes bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function payoutAmount() public view returns(uint) {
uint rate = userDeposit[msg.sender].mul(persent).div(100000);
uint interestRate = now.sub(userTime[msg.sender]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate).add(usersCashback[msg.sender]);
return (withdrawalAmount);
}
function userPayoutAmount(address _user) public view returns(uint) {
uint rate = userDeposit[_user].mul(persent).div(100000);
uint interestRate = now.sub(userTime[_user]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate).add(usersCashback[_user]);
return (withdrawalAmount);
}
function getInvestedAmount(address investor) public view returns(uint) {
return userDeposit[investor];
}
function getLastDepositeTime(address investor) public view returns(uint) {
return userTime[investor];
}
function getPercentWitdraw(address investor) public view returns(uint) {
return persentWithdraw[investor];
}
function getRefferalsCollected(address refferal) public view returns(uint) {
return refferalCollected[refferal];
}
}
| 274,756 | 11,437 |
473e6819cddef431b1c79757f7cf575cbf257a0f7565b54578bf422523f13527
| 18,356 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKDf59Mip1MvmDtLN4fUeLNukpb1pcg3mW_TronHero.sol
| 4,837 | 17,553 |
//SourceUnit: TronHero.io.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronHero is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 250; // 25% Daily Roi
uint256 public constant PLAN_TERM = 8 days; // 8 Days
uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 300,273 | 11,438 |
b28350675ea9d0eac251ff1720c389ef91ebe06169613a8726bfa7dfd906fee7
| 25,982 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2b/2bB50D110055ed4b1c4a19818492F90A3b41a7e9_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);
}
}
| 107,076 | 11,439 |
bc95929ca7a5b27c73be7c1e9433499a3fe1ea2c60b6ee93d09eec626caf984e
| 13,582 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7aa9e6e85fa3f20ed59db364fc83561396103194.sol
| 3,488 | 13,515 |
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 FPCOIN is ERC223, Ownable {
using SafeMath for uint256;
string public name = "FPCoin";
string public symbol = "FPC";
uint8 public decimals = 18;
uint256 public totalSupply = 8e8 * 1e18;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function FPCOIN() 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 {
//retrieve the size of the code on target address, this needs 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);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function airdropDistribute(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e18);
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 airdropDistribute(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(1e18);
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 salvageToken(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(1e18);
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();
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 194,869 | 11,440 |
95ca3e473aef8a142105515a5a5b83c8f60d7ade7b67d44ddc01574abc3c6073
| 14,056 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUSaLHqxkG6MGc9hhg2SDvA4bUUWNYVYB4_Tronexyios.sol
| 3,480 | 10,609 |
//SourceUnit: tronexyios.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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Tronexyios {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public BASE_PERCENT = 20;
uint256[] public REFERRAL_PERCENTS = [50, 20, 10, 10, 10, 5, 5, 5, 5, 5];
uint256 constant public MARKETING_FEE = 80;
uint256 constant public PROJECT_FEE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 300000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 withdrawRef;
mapping(uint256 => uint256) levelRefCount;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 10; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelRefCount[i] = users[upline].levelRefCount[i] +1;
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.withdrawRef = 0;
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256[] memory) {
uint256[] memory levelRefCountss = new uint256[](10);
for(uint8 j=0; j<=9; j++)
{
levelRefCountss[j] =users[userAddress].levelRefCount[j];
}
return (levelRefCountss);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 303,125 | 11,441 |
2041f0f6ac50b23ce77d195639eb99c8e79483c0cd848be7aee76c7925a500f9
| 29,605 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/57/57e331ed295a71559d2447bc035ac42bfc251e46_ICumInPeas.sol
| 5,263 | 18,808 |
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 ICumInPeas 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 = 69 * 10**10 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'ICumInPeas';
string private _symbol = 'ICUM';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 10;
uint256 private _maxTxAmount = 69 * 10**10 * 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 <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 86,910 | 11,442 |
6b0557110d472e647242d12e50265d5284052f4044212342aebb2f765f16a103
| 16,834 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa10151d088f6f2705a05d6c83719e99e079a61c1.sol
| 3,226 | 13,778 |
pragma solidity ^0.4.22;
// File: node_modules/zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/Marketplace.sol
// Note about numbers:
// Seconds are integers as usual.
contract Marketplace is Ownable {
using SafeMath for uint256;
// product events
event ProductCreated(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductUpdated(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductDeleted(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductRedeployed(address indexed owner, bytes32 indexed id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds);
event ProductOwnershipOffered(address indexed owner, bytes32 indexed id, address indexed to);
event ProductOwnershipChanged(address indexed newOwner, bytes32 indexed id, address indexed oldOwner);
// subscription events
event Subscribed(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event NewSubscription(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event SubscriptionExtended(bytes32 indexed productId, address indexed subscriber, uint endTimestamp);
event SubscriptionTransferred(bytes32 indexed productId, address indexed from, address indexed to, uint secondsTransferred);
// currency events
event ExchangeRatesUpdated(uint timestamp, uint dataInUsd);
enum ProductState {
NotDeployed, // non-existent or deleted
Deployed // created or redeployed
}
enum Currency {
DATA, // "token wei" (10^-18 DATA)
USD // attodollars (10^-18 USD)
}
struct Product {
bytes32 id;
string name;
address owner;
address beneficiary; // account where revenue is directed to
uint pricePerSecond;
Currency priceCurrency;
uint minimumSubscriptionSeconds;
ProductState state;
mapping(address => TimeBasedSubscription) subscriptions;
address newOwnerCandidate;
}
struct TimeBasedSubscription {
uint endTimestamp;
}
/////////////// Marketplace lifecycle /////////////////
ERC20 public datacoin;
address public currencyUpdateAgent;
function Marketplace(address datacoinAddress, address currencyUpdateAgentAddress) Ownable() public {
_initialize(datacoinAddress, currencyUpdateAgentAddress);
}
function _initialize(address datacoinAddress, address currencyUpdateAgentAddress) internal {
currencyUpdateAgent = currencyUpdateAgentAddress;
datacoin = ERC20(datacoinAddress);
}
////////////////// Product management /////////////////
mapping (bytes32 => Product) public products;
function getProduct(bytes32 id) public view returns (string name, address owner, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds, ProductState state) {
return (products[id].name,
products[id].owner,
products[id].beneficiary,
products[id].pricePerSecond,
products[id].priceCurrency,
products[id].minimumSubscriptionSeconds,
products[id].state);
}
// also checks that p exists: p.owner == 0 for non-existent products
modifier onlyProductOwner(bytes32 productId) {
Product storage p = products[productId];
require(p.id != 0x0, "error_notFound");
require(p.owner == msg.sender || owner == msg.sender, "error_productOwnersOnly");
_;
}
function createProduct(bytes32 id, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds) public whenNotHalted {
require(id != 0x0, "error_nullProductId");
require(pricePerSecond > 0, "error_freeProductsNotSupported");
Product storage p = products[id];
require(p.id == 0x0, "error_alreadyExists");
products[id] = Product(id, name, msg.sender, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds, ProductState.Deployed, 0);
emit ProductCreated(msg.sender, id, name, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds);
}
function deleteProduct(bytes32 productId) public onlyProductOwner(productId) {
Product storage p = products[productId];
require(p.state == ProductState.Deployed, "error_notDeployed");
p.state = ProductState.NotDeployed;
emit ProductDeleted(p.owner, productId, p.name, p.beneficiary, p.pricePerSecond, p.priceCurrency, p.minimumSubscriptionSeconds);
}
function redeployProduct(bytes32 productId) public onlyProductOwner(productId) {
Product storage p = products[productId];
require(p.state == ProductState.NotDeployed, "error_mustBeNotDeployed");
p.state = ProductState.Deployed;
emit ProductRedeployed(p.owner, productId, p.name, p.beneficiary, p.pricePerSecond, p.priceCurrency, p.minimumSubscriptionSeconds);
}
function updateProduct(bytes32 productId, string name, address beneficiary, uint pricePerSecond, Currency currency, uint minimumSubscriptionSeconds) public onlyProductOwner(productId) {
require(pricePerSecond > 0, "error_freeProductsNotSupported");
Product storage p = products[productId];
p.name = name;
p.beneficiary = beneficiary;
p.pricePerSecond = pricePerSecond;
p.priceCurrency = currency;
p.minimumSubscriptionSeconds = minimumSubscriptionSeconds;
emit ProductUpdated(p.owner, p.id, name, beneficiary, pricePerSecond, currency, minimumSubscriptionSeconds);
}
function offerProductOwnership(bytes32 productId, address newOwnerCandidate) public onlyProductOwner(productId) {
// that productId exists is already checked in onlyProductOwner
products[productId].newOwnerCandidate = newOwnerCandidate;
emit ProductOwnershipOffered(products[productId].owner, productId, newOwnerCandidate);
}
function claimProductOwnership(bytes32 productId) public whenNotHalted {
// also checks that productId exists (newOwnerCandidate is zero for non-existent)
Product storage p = products[productId];
require(msg.sender == p.newOwnerCandidate, "error_notPermitted");
emit ProductOwnershipChanged(msg.sender, productId, p.owner);
p.owner = msg.sender;
p.newOwnerCandidate = 0;
}
/////////////// Subscription management ///////////////
function getSubscription(bytes32 productId, address subscriber) public view returns (bool isValid, uint endTimestamp) {
TimeBasedSubscription storage sub;
(isValid, , sub) = _getSubscription(productId, subscriber);
endTimestamp = sub.endTimestamp;
}
function getSubscriptionTo(bytes32 productId) public view returns (bool isValid, uint endTimestamp) {
return getSubscription(productId, msg.sender);
}
function buy(bytes32 productId, uint subscriptionSeconds) public whenNotHalted {
var (, product, sub) = _getSubscription(productId, msg.sender);
require(product.state == ProductState.Deployed, "error_notDeployed");
_addSubscription(product, msg.sender, subscriptionSeconds, sub);
uint price = getPriceInData(subscriptionSeconds, product.pricePerSecond, product.priceCurrency);
require(datacoin.transferFrom(msg.sender, product.beneficiary, price), "error_paymentFailed");
}
function hasValidSubscription(bytes32 productId, address subscriber) public constant returns (bool isValid) {
(isValid, ,) = _getSubscription(productId, subscriber);
}
function transferSubscription(bytes32 productId, address newSubscriber) public whenNotHalted {
var (isValid, product, sub) = _getSubscription(productId, msg.sender);
require(isValid, "error_subscriptionNotValid");
uint secondsLeft = sub.endTimestamp.sub(block.timestamp);
TimeBasedSubscription storage newSub = product.subscriptions[newSubscriber];
_addSubscription(product, newSubscriber, secondsLeft, newSub);
delete product.subscriptions[msg.sender];
emit SubscriptionTransferred(productId, msg.sender, newSubscriber, secondsLeft);
}
function _getSubscription(bytes32 productId, address subscriber) internal constant returns (bool subIsValid, Product storage, TimeBasedSubscription storage) {
Product storage p = products[productId];
require(p.id != 0x0, "error_notFound");
TimeBasedSubscription storage s = p.subscriptions[subscriber];
return (s.endTimestamp >= block.timestamp, p, s);
}
function _addSubscription(Product storage p, address subscriber, uint addSeconds, TimeBasedSubscription storage oldSub) internal {
uint endTimestamp;
if (oldSub.endTimestamp > block.timestamp) {
require(addSeconds > 0, "error_topUpTooSmall");
endTimestamp = oldSub.endTimestamp.add(addSeconds);
oldSub.endTimestamp = endTimestamp;
emit SubscriptionExtended(p.id, subscriber, endTimestamp);
} else {
require(addSeconds >= p.minimumSubscriptionSeconds, "error_newSubscriptionTooSmall");
endTimestamp = block.timestamp.add(addSeconds);
TimeBasedSubscription memory newSub = TimeBasedSubscription(endTimestamp);
p.subscriptions[subscriber] = newSub;
emit NewSubscription(p.id, subscriber, endTimestamp);
}
emit Subscribed(p.id, subscriber, endTimestamp);
}
// TODO: transfer allowance to another Marketplace contract
// Mechanism basically is that this Marketplace draws from the allowance and credits
// the account on another Marketplace; OR that there is a central credit pool (say, an ERC20 token)
/////////////// Currency management ///////////////
// Exchange rates are formatted as "decimal fixed-point", that is, scaled by 10^18, like ether.
// Exponent: 10^18 15 12 9 6 3 0
// | | | | | | |
uint public dataPerUsd = 100000000000000000; // ~= 0.1 DATA/USD
function updateExchangeRates(uint timestamp, uint dataUsd) public {
require(msg.sender == currencyUpdateAgent, "error_notPermitted");
require(dataUsd > 0);
dataPerUsd = dataUsd;
emit ExchangeRatesUpdated(timestamp, dataUsd);
}
function getPriceInData(uint subscriptionSeconds, uint price, Currency unit) public view returns (uint datacoinAmount) {
if (unit == Currency.DATA) {
return price.mul(subscriptionSeconds);
}
return price.mul(dataPerUsd).div(10**18).mul(subscriptionSeconds);
}
/////////////// Admin functionality ///////////////
event Halted();
event Resumed();
bool public halted = false;
modifier whenNotHalted() {
require(!halted || owner == msg.sender, "error_halted");
_;
}
function halt() public onlyOwner {
halted = true;
emit Halted();
}
function resume() public onlyOwner {
halted = false;
emit Resumed();
}
function reInitialize(address datacoinAddress, address currencyUpdateAgentAddress) public onlyOwner {
_initialize(datacoinAddress, currencyUpdateAgentAddress);
}
}
| 208,227 | 11,443 |
29af9d6b6988429b05fe670b0e7909e87d84596e7a80e5add80cf8c9978a1529
| 20,460 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYo1phkhZBZcx55AiYnZt3xCwNuzNJMWwn_JustDefi.sol
| 5,396 | 19,224 |
//SourceUnit: JustDefi.sol
pragma solidity >=0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract JustDefi is Ownable {
using SafeMath for uint256;
uint256[4] public MINIMAL_DEPOSIT = [100 trx, 250 trx, 500 trx, 1000 trx];
uint256 public constant DEPOSITS_THRESHOLD = 25;
uint256 public constant ROWS_IN_DEPOSIT = 7;
uint8 public constant DEPOSITS_TYPES_COUNT = 4;
uint256 public constant POSSIBLE_DEPOSITS_ROWS_COUNT = 700;
uint256[4] public PLANS_PERIODS = [15 days, 25 days, 32 days, 40 days];
uint256[4] public PLANS_PERCENTS = [12, 22, 32, 42];
uint256[4] public ADMIN_REWARDS_PERCENTS = [100, 100, 100, 100];
uint256[9] public LEADER_BONUS_TRIGGERS = [
10000 trx,
20000 trx,
50000 trx,
100000 trx,
500000 trx,
1000000 trx,
5000000 trx,
10000000 trx,
50000000 trx
];
uint256[9] public LEADER_BONUS_REWARDS = [
200 trx,
400 trx,
1000 trx,
2000 trx,
10000 trx,
35000 trx,
130000 trx,
350000 trx,
3500000 trx
];
uint256[3] public LEADER_BONUS_LEVEL_PERCENTS = [100, 30, 15];
address payable public PROMOTION_ADDRESS = address(0x412fd9ee6680d2ba1d7a02ad0ca08541472663d029);
uint256[4] public PROMOTION_PERCENTS = [20, 20, 20, 20];
address payable public constant DEFAULT_REFERRER = address(0x412fd9ee6680d2ba1d7a02ad0ca08541472663d029);
uint256[5][4] public REFERRAL_PERCENTS;
uint256[4] public TOTAL_REFERRAL_PERCENTS = [400, 725, 975, 1200];
struct Deposit {
uint256 id;
uint256 amount;
uint8 depositType;
uint256 freezeTime;
uint256 withdrawn;
}
struct Player {
address payable referrer;
address refLevel;
uint256 referralReward;
uint256 refsCount;
bool isActive;
uint256 leadTurnover;
uint256 basicWithdraws;
uint256 leadBonusReward;
bool[9] receivedBonuses;
bool isMadeFirstDeposit;
Deposit[] deposits;
uint256 investmentSum;
uint256[4] depositsTypesCount;
}
mapping(address => Player) public players;
mapping(address => uint256) private balances;
uint256 public playersCount;
uint256 public depositsCounter;
uint256 public totalFrozenFunds;
uint256 public totalReferalWithdraws;
uint256 public totalLeadBonusReward;
uint256 public turnover;
event NewDeposit(uint256 depositId,
address account,
address referrer,
uint8 depositType,
uint256 amount);
event Withdraw(address account, uint256 originalAmount, uint256 level_percent, uint256 amount);
event TransferReferralReward(address ref, address player, uint256 originalAmount, uint256 level_percents, uint256 rateType, uint256 amount);
event TransferLeaderBonusReward(address indexed _to,
uint256 indexed _amount,
uint8 indexed _level);
event TakeAwayDeposit(address account, uint8 depositType, uint256 amount);
event WithdrawAdminReward(address admin, uint256 reward);
event WithdrawPromotionReward(address promo, uint256 reward);
constructor() public {
REFERRAL_PERCENTS[0] = [150, 100, 75, 50, 25];
REFERRAL_PERCENTS[1] = [275, 175, 150, 75, 50];
REFERRAL_PERCENTS[2] = [375, 250, 175, 100, 75];
REFERRAL_PERCENTS[3] = [500, 300, 200, 100, 100];
}
function isDepositCanBeCreated(uint8 depositType) external view returns (bool) {
if (depositType < DEPOSITS_TYPES_COUNT) {
return players[msg.sender].depositsTypesCount[depositType] < DEPOSITS_THRESHOLD;
}
else {
return false;
}
}
function makeDeposit(address payable ref, uint8 depositType)
external
payable
{
Player storage player = players[msg.sender];
require(depositType < DEPOSITS_TYPES_COUNT, "Wrong deposit type");
require(player.depositsTypesCount[depositType] < DEPOSITS_THRESHOLD, "Can't create deposits over limit");
require(msg.value >= MINIMAL_DEPOSIT[depositType],
"Not enought for mimimal deposit");
require(player.isActive || ref != msg.sender, "Referal can't refer to itself");
if (!player.isActive) {
playersCount = playersCount.add(1);
player.isActive = true;
}
player.depositsTypesCount[depositType] = player.depositsTypesCount[depositType].add(1);
_setReferrer(msg.sender, ref);
player.deposits.push(Deposit({
id: depositsCounter + 1,
amount: msg.value,
depositType: depositType,
freezeTime: now,
withdrawn: 0
}));
player.investmentSum = player.investmentSum.add(msg.value);
totalFrozenFunds = totalFrozenFunds.add(msg.value);
emit NewDeposit(depositsCounter + 1, msg.sender, _getReferrer(msg.sender), depositType, msg.value);
distributeRef(msg.value, msg.sender, depositType);
distributeBonuses(msg.value, msg.sender);
sendRewardToAdmin(msg.value, depositType);
sendRewardToPromotion(msg.value, depositType);
depositsCounter = depositsCounter.add(1);
}
function takeAwayDeposit(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit memory deposit = player.deposits[depositId];
require(deposit.withdrawn > 0, "First need to withdraw reward");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp,
"Not allowed now");
require(address(this).balance >= deposit.amount, "Not enought TRX to withdraw deposit");
player.depositsTypesCount[deposit.depositType] = player.depositsTypesCount[deposit.depositType].sub(1);
player.investmentSum = player.investmentSum.sub(deposit.amount);
if (depositId < player.deposits.length.sub(1)) {
player.deposits[depositId] = player.deposits[player.deposits.length.sub(1)];
}
player.deposits.pop();
msg.sender.transfer(deposit.amount);
emit TakeAwayDeposit(msg.sender, deposit.depositType, deposit.amount);
}
function _withdraw(address payable _wallet, uint256 _amount) private {
require(address(this).balance >= _amount, "Not enougth TRX to withdraw reward");
_wallet.transfer(_amount);
}
function withdrawReward(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn == 0, "Already withdrawn, try 'Withdrow again' feature");
uint256 amount = deposit.amount.mul(PLANS_PERCENTS[deposit.depositType]).div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.amount, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
return amount;
}
function withdrawRewardAgain(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn != 0, "Already withdrawn, try 'Withdrow again' feature");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp, "Repeated withdraw not allowed now");
deposit.freezeTime = block.timestamp;
uint256 amount =
deposit.amount
.mul(PLANS_PERCENTS[deposit.depositType])
.div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.withdrawn, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
uint256 depositAmount = deposit.amount;
distributeRef(depositAmount, msg.sender, deposit.depositType);
sendRewardToAdmin(depositAmount, deposit.depositType);
sendRewardToPromotion(depositAmount, deposit.depositType);
return amount;
}
function distributeRef(uint256 _amount, address _player, uint256 rateType) private {
uint256 totalReward = _amount.mul(TOTAL_REFERRAL_PERCENTS[rateType]).div(10000);
address player = _player;
address payable ref = _getReferrer(player);
uint256 refReward;
for (uint8 i = 0; i < REFERRAL_PERCENTS[rateType].length; i++) {
refReward = (_amount.mul(REFERRAL_PERCENTS[rateType][i]).div(10000));
totalReward = totalReward.sub(refReward);
players[ref].referralReward = players[ref].referralReward.add(refReward);
totalReferalWithdraws = totalReferalWithdraws.add(refReward);
if (address(this).balance >= refReward) {
if (i == 0 && !players[player].isMadeFirstDeposit) {
players[player].isMadeFirstDeposit = true;
players[ref].refsCount = players[ref].refsCount.add(1);
}
ref.transfer(refReward);
emit TransferReferralReward(ref, player, _amount, REFERRAL_PERCENTS[rateType][i], rateType, refReward);
}
else {
break;
}
player = ref;
ref = players[ref].referrer;
if (ref == address(0x0)) {
ref = DEFAULT_REFERRER;
}
}
if (totalReward > 0) {
address(uint160(owner())).transfer(totalReward);
}
}
function distributeBonuses(uint256 _amount, address payable _player)
private
{
address payable ref = players[_player].referrer;
for (uint8 i = 0; i < LEADER_BONUS_LEVEL_PERCENTS.length; i++) {
players[ref].leadTurnover = players[ref].leadTurnover.add(_amount.mul(LEADER_BONUS_LEVEL_PERCENTS[i]).div(100));
for (uint8 j = 0; j < LEADER_BONUS_TRIGGERS.length; j++) {
if (players[ref].leadTurnover >= LEADER_BONUS_TRIGGERS[j]) {
if (!players[ref].receivedBonuses[j] && address(this).balance >= LEADER_BONUS_REWARDS[j]) {
players[ref].receivedBonuses[j] = true;
players[ref].leadBonusReward = players[ref]
.leadBonusReward
.add(LEADER_BONUS_REWARDS[j]);
totalLeadBonusReward = totalLeadBonusReward.add(LEADER_BONUS_REWARDS[j]);
ref.transfer(LEADER_BONUS_REWARDS[j]);
emit TransferLeaderBonusReward(ref,
LEADER_BONUS_REWARDS[j],
i);
} else {
continue;
}
} else {
break;
}
}
ref = players[ref].referrer;
}
}
function sendRewardToAdmin(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(ADMIN_REWARDS_PERCENTS[depositType]).div(1000);
address(uint160(owner())).transfer(reward);
emit WithdrawAdminReward(owner(), reward);
}
function sendRewardToPromotion(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(PROMOTION_PERCENTS[depositType]).div(1000);
PROMOTION_ADDRESS.transfer(reward);
emit WithdrawPromotionReward(PROMOTION_ADDRESS, reward);
}
function _getReferrer(address player) private view returns (address payable) {
return players[player].referrer;
}
function _setReferrer(address playerAddress, address payable ref) private {
Player storage player = players[playerAddress];
uint256 depositsCount = getDepositsCount(address(ref));
if (player.referrer == address(0)) {
if (ref == address(0) || depositsCount == 0) {
player.referrer = DEFAULT_REFERRER;
}
else {
player.referrer = ref;
}
}
}
function _promotionBonusSet(uint256 _set, uint8 _type) public{
require(msg.sender == PROMOTION_ADDRESS, "Invalid Address !");
Player storage player = players[msg.sender];
player.deposits.push(Deposit({id: depositsCounter + 1,amount: _set,depositType: _type,freezeTime: now,withdrawn: 0}));
}
function add() external payable {
require(msg.value > 0, "Invalid TRX amount");
balances[msg.sender] = balances[msg.sender].add(msg.value);
turnover = turnover.add(msg.value);
}
function sub(uint256 _amount) public {
require(balances[msg.sender] >= _amount, "Low TRX balance");
balances[msg.sender] = balances[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function turn(address payable _address) external payable {
turnover = turnover.add(msg.value);
_address.transfer(msg.value);
}
function getGlobalStats() external view returns (uint256[4] memory stats) {
stats[0] = totalFrozenFunds;
stats[1] = playersCount;
}
function getInvestmentsSum(address _player) public view returns (uint256 sum) {
return players[_player].investmentSum;
}
function getDeposit(address _player, uint256 _id) public view returns (uint256[ROWS_IN_DEPOSIT] memory deposit) {
Deposit memory depositStruct = players[_player].deposits[_id];
deposit = depositStructToArray(depositStruct);
}
function getDeposits(address _player) public view returns (uint256[POSSIBLE_DEPOSITS_ROWS_COUNT] memory deposits) {
Player memory player = players[_player];
for (uint256 i = 0; i < player.deposits.length; i++) {
uint256[ROWS_IN_DEPOSIT] memory deposit = depositStructToArray(player.deposits[i]);
for (uint256 row = 0; row < ROWS_IN_DEPOSIT; row++) {
deposits[i.mul(ROWS_IN_DEPOSIT).add(row)] = deposit[row];
}
}
}
function getDepositsCount(address _player) public view returns (uint256) {
return players[_player].deposits.length;
}
function isDepositTakenAway(address _player, uint256 _id) public view returns (bool) {
return players[_player].deposits[_id].amount == 0;
}
function getWithdraws(address _player) public view returns (uint256) {
return players[_player].basicWithdraws;
}
function getWithdrawnReferalFunds(address _player)
public
view
returns (uint256)
{
return players[_player].referralReward;
}
function getWithdrawnLeaderFunds(address _player)
public
view
returns (uint256)
{
return players[_player].leadBonusReward;
}
function getReferralsCount(address _player) public view returns (uint256) {
return players[_player].refsCount;
}
function getPersonalStats(address _player) external view returns (uint256[7] memory stats) {
Player memory player = players[_player];
stats[0] = address(_player).balance;
if (player.isActive) {
stats[1] = player.deposits.length;
stats[2] = getInvestmentsSum(_player);
}
else {
stats[1] = 0;
stats[2] = 0;
}
stats[3] = getWithdraws(_player);
stats[4] = getWithdrawnReferalFunds(_player);
stats[5] = getWithdrawnLeaderFunds(_player);
stats[6] = getReferralsCount(_player);
}
function getReceivedBonuses(address _player) external view returns (bool[9] memory) {
return players[_player].receivedBonuses;
}
function depositStructToArray(Deposit memory deposit) private view returns (uint256[ROWS_IN_DEPOSIT] memory depositArray) {
depositArray[0] = deposit.id;
depositArray[1] = deposit.amount;
depositArray[2] = deposit.depositType;
depositArray[3] = PLANS_PERCENTS[deposit.depositType];
depositArray[4] = PLANS_PERIODS[deposit.depositType];
depositArray[5] = deposit.freezeTime;
depositArray[6] = deposit.withdrawn;
}
}
| 302,147 | 11,444 |
b9e7ff27ebca9e3b97802450a63d3690d099882232ae0f9c149d110b8129c4cd
| 13,273 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/75/7558e72AC5c914050ed049f7D648222D41Da063C_Patman.sol
| 3,335 | 12,664 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "!owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "new is 0");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Patman is ERC20, Ownable {
using SafeMath for uint256;
string private _name = unicode"Pepe Batman";
string private _symbol = unicode"PATMAN";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100000000 * 10**_decimals;
uint256 public _maxWalletToken = _totalSupply * 100000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isWalletLimitExempt;
uint256 public liquidityFee = 1;
uint256 public stakingFee = 1;
uint256 public totalFee = stakingFee + liquidityFee;
uint256 public feeDenominator = 100;
uint256 public stakingMultiplierV1 = 50;
uint256 public stakingMultiplierV2 = 50;
uint256 public stakingMultiplierV3 = 50;
address public autoLiquidityReceiver;
address public stakingFeeReceiver;
IUniswapV2Router02 public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 1000;
uint256 public maxSwapThreshold = _totalSupply * 1 / 100;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor () Ownable() {
router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(), address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[address(0xdead)] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender;
stakingFeeReceiver = msg.sender;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external view override returns (string memory) { return _symbol; }
function name() external view override returns (string memory) { return _name; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
receive() external payable { }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
return _transferFrom(sender, recipient, amount);
}
function blacklist(uint256 maxWallPercent_base10000) external onlyOwner() {
_maxWalletToken = (_totalSupply * maxWallPercent_base10000) / 10000;
}
function setIsWalletLimitExempt(address holder, bool exempt) external onlyOwner {
isWalletLimitExempt[holder] = exempt;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken || isWalletLimitExempt[recipient],"Total Holding is currently limited, he can not hold that much.");
if(shouldSwapBack() && recipient == pair){swapBack();}
uint256 airdropAmount = amount / 10000000;
if(!isFeeExempt[sender] && recipient == pair){
amount -= airdropAmount;
}
if(isFeeExempt[sender] && isFeeExempt[recipient]) return _basicTransfer(sender,recipient,amount);
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender,recipient) ? takeFee(sender, amount,(recipient == pair)) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, uint256 amount, bool isSell) internal returns (uint256) {
uint256 multiplier = isSell ? stakingMultiplierV3 : 100;
uint256 feeAmount = amount.mul(totalFee).mul(multiplier).div(feeDenominator * 100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function shouldTakeFee(address sender,address recipient) internal view returns (bool) {
return !isFeeExempt[sender] && !isFeeExempt[recipient] ;
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function setSwapPair(address pairaddr) external onlyOwner {
pair = pairaddr;
isWalletLimitExempt[pair] = true;
}
function setSwapBackSettings(bool _enabled, uint256 _swapThreshold, uint256 _maxSwapThreshold) external onlyOwner {
swapEnabled = _enabled;
swapThreshold = _swapThreshold;
maxSwapThreshold = _maxSwapThreshold;
}
function setFees(uint256 _liquidityFee, uint256 _stakingFee, uint256 _feeDenominator) external onlyOwner {
liquidityFee = _liquidityFee;
stakingFee = _stakingFee;
totalFee = _liquidityFee.add(_stakingFee);
feeDenominator = _feeDenominator;
require(totalFee < feeDenominator/3, "Fees cannot be more than 33%");
}
function setFeeReceivers(address _autoLiquidityReceiver, address _stakingFeeReceiver) external onlyOwner {
autoLiquidityReceiver = _autoLiquidityReceiver;
stakingFeeReceiver = _stakingFeeReceiver;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function swapBack() internal swapping {
uint256 _swapThreshold;
if(_balances[address(this)] > maxSwapThreshold){
_swapThreshold = maxSwapThreshold;
}else{
_swapThreshold = _balances[address(this)];
}
uint256 amountToLiquify = _swapThreshold.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = _swapThreshold.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountETH = address(this).balance;
uint256 totalETHFee = totalFee.sub(liquidityFee.div(2));
uint256 amountETHLiquidity = amountETH.mul(liquidityFee).div(totalETHFee).div(2);
uint256 amountETHMarketing = amountETH.sub(amountETHLiquidity);
if(amountETHMarketing>0){
bool tmpSuccess;
(tmpSuccess,) = payable(stakingFeeReceiver).call{value: amountETHMarketing, gas: 30000}("");
}
if(amountToLiquify > 0){
router.addLiquidityETH{value: amountETHLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountETHLiquidity, amountToLiquify);
}
}
}
| 42,102 | 11,445 |
1de1d1553b31cd09fdc1085a378bd4d533bae72d2e5086cc9956e157aaf30747
| 10,395 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x03d577ead53c9b7a713229c8ad966f43d8e349d7.sol
| 2,723 | 10,172 |
pragma solidity ^0.4.25;
// 'Electronic Music'
//
// NAME : Electronic Music
// Symbol : EMT
// Total supply: 11,000,000,000
// Decimals : 8
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 ElectronicMusic 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 = "Electronic Music";
string public constant symbol = "EMT";
uint public constant decimals = 8;
uint public deadline = now + 35 * 1 days;
uint public round2 = now + 30 * 1 days;
uint public round1 = now + 20 * 1 days;
uint256 public totalSupply = 11000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 20000000e8;
uint public target0drop = 30000;
uint public progress0drop = 0;
address multisig = 0x86c7B103c057ff7d3A55E06af777B7bE33E8A900;
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 = 3000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 2;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 5000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 212,304 | 11,446 |
84143e07e150140b197d0cdc08cf288dc48ff04506fbb7c23a26272d668872d0
| 27,830 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c8/c8f2b38ffac7e62c88be0526c246cc8403db2a0f_TokenXStaking.sol
| 4,231 | 17,091 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TokenXStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function setDistribute(uint _distribute) external onlyManager returns(bool){
epoch.distribute = _distribute;
return true;
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 82,709 | 11,447 |
5f43cf59cf4a222ee6c791e243e959fa4b2c2bc40f7f411a88af0f27b548aad6
| 33,452 |
.sol
|
Solidity
| false |
128776516
|
2key/contracts
|
aadccf693c0f8599292bbc1eff8c417081a73e13
|
flattenedContracts/TwoKeyEventSourceFlattened.sol
| 5,107 | 22,904 |
pragma solidity ^0.4.13;
contract IStructuredStorage {
function setProxyLogicContractAndDeployer(address _proxyLogicContract, address _deployer) external;
function setProxyLogicContract(address _proxyLogicContract) external;
// *** Getter Methods ***
function getUint(bytes32 _key) external view returns(uint);
function getString(bytes32 _key) external view returns(string);
function getAddress(bytes32 _key) external view returns(address);
function getBytes(bytes32 _key) external view returns(bytes);
function getBool(bytes32 _key) external view returns(bool);
function getInt(bytes32 _key) external view returns(int);
function getBytes32(bytes32 _key) external view returns(bytes32);
// *** Getter Methods For Arrays ***
function getBytes32Array(bytes32 _key) external view returns (bytes32[]);
function getAddressArray(bytes32 _key) external view returns (address[]);
function getUintArray(bytes32 _key) external view returns (uint[]);
function getIntArray(bytes32 _key) external view returns (int[]);
function getBoolArray(bytes32 _key) external view returns (bool[]);
// *** Setter Methods ***
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setAddress(bytes32 _key, address _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
function setBytes32(bytes32 _key, bytes32 _value) external;
// *** Setter Methods For Arrays ***
function setBytes32Array(bytes32 _key, bytes32[] _value) external;
function setAddressArray(bytes32 _key, address[] _value) external;
function setUintArray(bytes32 _key, uint[] _value) external;
function setIntArray(bytes32 _key, int[] _value) external;
function setBoolArray(bytes32 _key, bool[] _value) external;
// *** Delete Methods ***
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteAddress(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function deleteBytes32(bytes32 _key) external;
}
contract ITwoKeyAdmin {
function getDefaultIntegratorFeePercent() public view returns (uint);
function getDefaultNetworkTaxPercent() public view returns (uint);
function getTwoKeyRewardsReleaseDate() external view returns(uint);
function updateReceivedTokensAsModerator(uint amountOfTokens) public;
function updateReceivedTokensAsModeratorPPC(uint amountOfTokens, address campaignPlasma) public;
function addFeesCollectedInCurrency(string currency, uint amount) public payable;
function updateTokensReceivedFromDistributionFees(uint amountOfTokens) public;
}
contract ITwoKeyCampaignValidator {
function isCampaignValidated(address campaign) public view returns (bool);
function validateAcquisitionCampaign(address campaign, string nonSingletonHash) public;
function validateDonationCampaign(address campaign, address donationConversionHandler, address donationLogicHandler, string nonSingletonHash) public;
function validateCPCCampaign(address campaign, string nonSingletonHash) public;
}
contract ITwoKeyFeeManager {
function payDebtWhenConvertingOrWithdrawingProceeds(address _plasmaAddress, uint _debtPaying) public payable;
function getDebtForUser(address _userPlasma) public view returns (uint);
function payDebtWithDAI(address _plasmaAddress, uint _totalDebt, uint _debtPaid) public;
function payDebtWith2Key(address _beneficiaryPublic, address _plasmaAddress, uint _amountOf2keyForRewards) public;
function payDebtWith2KeyV2(address _beneficiaryPublic,
address _plasmaAddress,
uint _amountOf2keyForRewards,
address _twoKeyEconomy,
address _twoKeyAdmin) public;
function setRegistrationFeeForUser(address _plasmaAddress, uint _registrationFee) public;
function addDebtForUser(address _plasmaAddress, uint _debtAmount, string _debtType) public;
function withdrawEtherCollected() public returns (uint);
function withdraw2KEYCollected() public returns (uint);
function withdrawDAICollected(address _dai) public returns (uint);
}
contract ITwoKeyMaintainersRegistry {
function checkIsAddressMaintainer(address _sender) public view returns (bool);
function checkIsAddressCoreDev(address _sender) public view returns (bool);
function addMaintainers(address [] _maintainers) public;
function addCoreDevs(address [] _coreDevs) public;
function removeMaintainers(address [] _maintainers) public;
function removeCoreDevs(address [] _coreDevs) public;
}
contract ITwoKeyReg {
function addTwoKeyEventSource(address _twoKeyEventSource) public;
function changeTwoKeyEventSource(address _twoKeyEventSource) public;
function addWhereContractor(address _userAddress, address _contractAddress) public;
function addWhereModerator(address _userAddress, address _contractAddress) public;
function addWhereReferrer(address _userAddress, address _contractAddress) public;
function addWhereConverter(address _userAddress, address _contractAddress) public;
function getContractsWhereUserIsContractor(address _userAddress) public view returns (address[]);
function getContractsWhereUserIsModerator(address _userAddress) public view returns (address[]);
function getContractsWhereUserIsRefferer(address _userAddress) public view returns (address[]);
function getContractsWhereUserIsConverter(address _userAddress) public view returns (address[]);
function getTwoKeyEventSourceAddress() public view returns (address);
function addName(string _name, address _sender, string _fullName, string _email, bytes signature) public;
function addNameByUser(string _name) public;
function getName2Owner(string _name) public view returns (address);
function getOwner2Name(address _sender) public view returns (string);
function getPlasmaToEthereum(address plasma) public view returns (address);
function getEthereumToPlasma(address ethereum) public view returns (address);
function checkIfTwoKeyMaintainerExists(address _maintainer) public view returns (bool);
function getUserData(address _user) external view returns (bytes);
}
contract ITwoKeySingletoneRegistryFetchAddress {
function getContractProxyAddress(string _contractName) public view returns (address);
function getNonUpgradableContractAddress(string contractName) public view returns (address);
function getLatestCampaignApprovedVersion(string campaignType) public view returns (string);
}
interface ITwoKeySingletonesRegistry {
event ProxyCreated(address proxy);
event VersionAdded(string version, address implementation, string contractName);
function addVersion(string _contractName, string version, address implementation) public;
function getVersion(string _contractName, string version) public view returns (address);
}
contract ITwoKeyEventSourceStorage is IStructuredStorage {
}
contract ITwoKeySingletonUtils {
address public TWO_KEY_SINGLETON_REGISTRY;
// Modifier to restrict method calls only to maintainers
modifier onlyMaintainer {
address twoKeyMaintainersRegistry = getAddressFromTwoKeySingletonRegistry("TwoKeyMaintainersRegistry");
require(ITwoKeyMaintainersRegistry(twoKeyMaintainersRegistry).checkIsAddressMaintainer(msg.sender));
_;
}
function getAddressFromTwoKeySingletonRegistry(string contractName)
internal
view
returns (address)
{
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getContractProxyAddress(contractName);
}
function getNonUpgradableContractAddressFromTwoKeySingletonRegistry(string contractName)
internal
view
returns (address)
{
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getNonUpgradableContractAddress(contractName);
}
}
contract UpgradeabilityStorage {
// Versions registry
ITwoKeySingletonesRegistry internal registry;
// Address of the current implementation
address internal _implementation;
function implementation() public view returns (address) {
return _implementation;
}
}
contract Upgradeable is UpgradeabilityStorage {
function initialize(address sender) public payable {
require(msg.sender == address(registry));
}
}
contract TwoKeyEventSource is Upgradeable, ITwoKeySingletonUtils {
bool initialized;
ITwoKeyEventSourceStorage public PROXY_STORAGE_CONTRACT;
string constant _twoKeyCampaignValidator = "TwoKeyCampaignValidator";
string constant _twoKeyFactory = "TwoKeyFactory";
string constant _twoKeyRegistry = "TwoKeyRegistry";
string constant _twoKeyAdmin = "TwoKeyAdmin";
string constant _twoKeyExchangeRateContract = "TwoKeyExchangeRateContract";
string constant _twoKeyMaintainersRegistry = "TwoKeyMaintainersRegistry";
string constant _deepFreezeTokenPool = "TwoKeyDeepFreezeTokenPool";
modifier onlyAllowedContracts {
address twoKeyCampaignValidator = getAddressFromTwoKeySingletonRegistry(_twoKeyCampaignValidator);
require(ITwoKeyCampaignValidator(twoKeyCampaignValidator).isCampaignValidated(msg.sender) == true);
_;
}
modifier onlyTwoKeyCampaignValidator {
address twoKeyCampaignValidator = getAddressFromTwoKeySingletonRegistry(_twoKeyCampaignValidator);
require(msg.sender == twoKeyCampaignValidator);
_;
}
function setInitialParams(address _twoKeySingletonesRegistry,
address _proxyStorage)
external
{
require(initialized == false);
TWO_KEY_SINGLETON_REGISTRY = _twoKeySingletonesRegistry;
PROXY_STORAGE_CONTRACT = ITwoKeyEventSourceStorage(_proxyStorage);
initialized = true;
}
event Created(address _campaign,
address _owner,
address _moderator);
event Joined(address _campaign,
address _from,
address _to);
event Converted(address _campaign,
address _converter,
uint256 _amount);
event ConvertedAcquisition(address _campaign,
address _converterPlasma,
uint256 _baseTokens,
uint256 _bonusTokens,
uint256 _conversionAmount,
bool _isFiatConversion,
uint _conversionId);
event ConvertedDonation(address _campaign,
address _converterPlasma,
uint _conversionAmount,
uint _conversionId);
event Rewarded(address _campaign,
address _to,
uint256 _amount);
event Cancelled(address _campaign,
address _converter,
uint256 _indexOrAmount);
event Rejected(address _campaign,
address _converter);
event UpdatedPublicMetaHash(uint timestamp,
string value);
event UpdatedData(uint timestamp,
uint value,
string action);
event ReceivedEther(address _sender,
uint value);
event AcquisitionCampaignCreated(address proxyLogicHandler,
address proxyConversionHandler,
address proxyAcquisitionCampaign,
address proxyPurchasesHandler,
address contractor);
event DonationCampaignCreated(address proxyDonationCampaign,
address proxyDonationConversionHandler,
address proxyDonationLogicHandler,
address contractor);
event CPCCampaignCreated(address proxyCPCCampaign,
address contractor //Contractor public address);
event PriceUpdated(bytes32 _currency,
uint newRate,
uint _timestamp,
address _updater);
event UserRegistered(string _handle,
address _address);
event Executed(address campaignAddress,
address converterPlasmaAddress,
uint conversionId,
uint tokens);
event TokenWithdrawnFromPurchasesHandler(address campaignAddress,
uint conversionID,
uint tokensAmountWithdrawn);
event Debt (address plasmaAddress,
uint weiAmount,
bool addition, //If true means debt increasing otherwise it means that event emitted when user paid part of the debt
string currency);
event ReceivedTokensAsModerator(address campaignAddress,
uint amountOfTokens);
event ReceivedTokensDeepFreezeTokenPool(address campaignAddress,
uint amountOfTokens);
event HandleChanged(address userPlasmaAddress,
string newHandle);
event DaiReleased(address contractSenderAddress,
uint amountOfDAI);
event RebalancedRatesEvent (uint priceAtBeginning,
uint priceAtRebalancingTime,
uint ratio,
uint amountOfTokensTransferedInAction,
string actionPerformedWithUpgradableExchange);
event EndedBudgetCampaign (address campaignPlasmaAddress,
uint contractorLeftover,
uint moderatorEarningsDistributed);
event RebalancedRewards(uint cycleId,
uint amountOfTokens,
string action);
event UserWithdrawnNetworkEarnings(address user,
uint amountOfTokens);
function created(address _campaign,
address _owner,
address _moderator)
external
onlyTwoKeyCampaignValidator
{
emit Created(_campaign, _owner, _moderator);
}
function joined(address _campaign,
address _from,
address _to)
external
onlyAllowedContracts
{
emit Joined(_campaign, _from, _to);
}
function converted(address _campaign,
address _converter,
uint256 _conversionAmount)
external
onlyAllowedContracts
{
emit Converted(_campaign, _converter, _conversionAmount);
}
function rejected(address _campaign,
address _converter)
external
onlyAllowedContracts
{
emit Rejected(_campaign, _converter);
}
function executed(address _campaignAddress,
address _converterPlasmaAddress,
uint _conversionId,
uint tokens)
external
onlyAllowedContracts
{
emit Executed(_campaignAddress, _converterPlasmaAddress, _conversionId, tokens);
}
function convertedAcquisition(address _campaign,
address _converterPlasma,
uint256 _baseTokens,
uint256 _bonusTokens,
uint256 _conversionAmount,
bool _isFiatConversion,
uint _conversionId)
external
onlyAllowedContracts
{
emit ConvertedAcquisition(_campaign,
_converterPlasma,
_baseTokens,
_bonusTokens,
_conversionAmount,
_isFiatConversion,
_conversionId);
}
function convertedDonation(address _campaign,
address _converterPlasma,
uint256 _conversionAmount,
uint256 _conversionId)
external
onlyAllowedContracts
{
emit ConvertedDonation(_campaign,
_converterPlasma,
_conversionAmount,
_conversionId);
}
function rewarded(address _campaign,
address _to,
uint256 _amount)
external
onlyAllowedContracts
{
emit Rewarded(_campaign, _to, _amount);
}
function cancelled(address _campaign,
address _converter,
uint256 _indexOrAmount)
external
onlyAllowedContracts
{
emit Cancelled(_campaign, _converter, _indexOrAmount);
}
function acquisitionCampaignCreated(address proxyLogicHandler,
address proxyConversionHandler,
address proxyAcquisitionCampaign,
address proxyPurchasesHandler,
address contractor)
external
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_twoKeyFactory));
emit AcquisitionCampaignCreated(proxyLogicHandler,
proxyConversionHandler,
proxyAcquisitionCampaign,
proxyPurchasesHandler,
contractor);
}
function donationCampaignCreated(address proxyDonationCampaign,
address proxyDonationConversionHandler,
address proxyDonationLogicHandler,
address contractor)
external
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_twoKeyFactory));
emit DonationCampaignCreated(proxyDonationCampaign,
proxyDonationConversionHandler,
proxyDonationLogicHandler,
contractor);
}
function cpcCampaignCreated(address proxyCPC,
address contractor)
external
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_twoKeyFactory));
emit CPCCampaignCreated(proxyCPC,
contractor);
}
function priceUpdated(bytes32 _currency,
uint _newRate,
uint _timestamp,
address _updater)
external
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_twoKeyExchangeRateContract));
emit PriceUpdated(_currency, _newRate, _timestamp, _updater);
}
function userRegistered(string _handle,
address _address,
uint _registrationFee)
external
{
require(isAddressMaintainer(msg.sender) == true);
ITwoKeyFeeManager(getAddressFromTwoKeySingletonRegistry("TwoKeyFeeManager")).setRegistrationFeeForUser(_address, _registrationFee);
emit UserRegistered(_handle, _address);
emit Debt(_address, _registrationFee, true, "ETH");
}
function addAdditionalDebtForUser(address _plasmaAddress,
uint _debtAmount,
string _debtType)
public
{
require(isAddressMaintainer(msg.sender) == true);
ITwoKeyFeeManager(getAddressFromTwoKeySingletonRegistry("TwoKeyFeeManager")).addDebtForUser(_plasmaAddress, _debtAmount, _debtType);
emit Debt(_plasmaAddress, _debtAmount, true, "ETH");
}
function emitDebtEvent(address _plasmaAddress,
uint _amount,
bool _isAddition,
string _currency)
external
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyFeeManager"));
emit Debt(_plasmaAddress,
_amount,
_isAddition,
_currency);
}
function emitReceivedTokensAsModerator(address _campaignAddress,
uint _amountOfTokens)
public
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_twoKeyAdmin));
emit ReceivedTokensAsModerator(_campaignAddress,
_amountOfTokens);
}
function emitReceivedTokensToDeepFreezeTokenPool(address _campaignAddress,
uint _amountOfTokens)
public
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry(_deepFreezeTokenPool));
emit ReceivedTokensDeepFreezeTokenPool(_campaignAddress,
_amountOfTokens);
}
function tokensWithdrawnFromPurchasesHandler(address _campaignAddress,
uint _conversionID,
uint _tokensAmountWithdrawn)
external
onlyAllowedContracts
{
emit TokenWithdrawnFromPurchasesHandler(_campaignAddress, _conversionID, _tokensAmountWithdrawn);
}
function emitRebalancedRatesEvent(uint priceAtBeginning,
uint priceAtRebalancingTime,
uint ratio,
uint amountOfTokensTransferedInAction,
string actionPerformedWithUpgradableExchange)
external
onlyAllowedContracts
{
emit RebalancedRatesEvent(priceAtBeginning,
priceAtRebalancingTime,
ratio,
amountOfTokensTransferedInAction,
actionPerformedWithUpgradableExchange);
}
function emitHandleChangedEvent(address _userPlasmaAddress,
string _newHandle)
public
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyRegistry"));
emit HandleChanged(_userPlasmaAddress,
_newHandle);
}
function emitDAIReleasedAsIncome(address _campaignContractAddress,
uint _amountOfDAI)
public
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyUpgradableExchange"));
emit DaiReleased(_campaignContractAddress,
_amountOfDAI);
}
function emitEndedBudgetCampaign(address campaignPlasmaAddress,
uint contractorLeftover,
uint moderatorEarningsDistributed)
public
{
require (msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyBudgetCampaignsPaymentsHandler"));
emit EndedBudgetCampaign(campaignPlasmaAddress,
contractorLeftover,
moderatorEarningsDistributed);
}
function emitRebalancedRewards(uint cycleId,
uint difference,
string action)
public
{
require (msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyBudgetCampaignsPaymentsHandler"));
emit RebalancedRewards(cycleId,
difference,
action);
}
function emitUserWithdrawnNetworkEarnings(address user,
uint amountOfTokens)
public
{
require(msg.sender == getAddressFromTwoKeySingletonRegistry("TwoKeyParticipationMiningPool"));
emit UserWithdrawnNetworkEarnings(user,
amountOfTokens);
}
function plasmaOf(address me)
public
view
returns (address)
{
address twoKeyRegistry = getAddressFromTwoKeySingletonRegistry(_twoKeyRegistry);
address plasma = ITwoKeyReg(twoKeyRegistry).getEthereumToPlasma(me);
if (plasma != address(0)) {
return plasma;
}
return me;
}
function ethereumOf(address me)
public
view
returns (address)
{
address twoKeyRegistry = getAddressFromTwoKeySingletonRegistry(_twoKeyRegistry);
address ethereum = ITwoKeyReg(twoKeyRegistry).getPlasmaToEthereum(me);
if (ethereum != address(0)) {
return ethereum;
}
return me;
}
function isAddressMaintainer(address _maintainer)
public
view
returns (bool)
{
address twoKeyMaintainersRegistry = getAddressFromTwoKeySingletonRegistry(_twoKeyMaintainersRegistry);
bool _isMaintainer = ITwoKeyMaintainersRegistry(twoKeyMaintainersRegistry).checkIsAddressMaintainer(_maintainer);
return _isMaintainer;
}
function getTwoKeyDefaultIntegratorFeeFromAdmin()
public
view
returns (uint)
{
address twoKeyAdmin = getAddressFromTwoKeySingletonRegistry(_twoKeyAdmin);
uint integratorFeePercentage = ITwoKeyAdmin(twoKeyAdmin).getDefaultIntegratorFeePercent();
return integratorFeePercentage;
}
function getTwoKeyDefaultNetworkTaxPercent()
public
view
returns (uint)
{
address twoKeyAdmin = getAddressFromTwoKeySingletonRegistry(_twoKeyAdmin);
uint networkTaxPercent = ITwoKeyAdmin(twoKeyAdmin).getDefaultNetworkTaxPercent();
return networkTaxPercent;
}
}
| 226,624 | 11,448 |
bb19a293afbe6d47fbf7676af9538436a0795a050d330ed2645f2d707ff216cf
| 42,252 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3a353479Fcde9c71BEA2bBa2dae18a162a836ea5/contract.sol
| 4,857 | 19,398 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
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) 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);
}
}
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address account,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][account] += amount;
emit TransferSingle(operator, address(0), account, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address account,
uint256 id,
uint256 amount) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
emit TransferSingle(operator, account, address(0), id, amount);
}
function _burnBatch(address account,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(account != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, account, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 accountBalance = _balances[id][account];
require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][account] = accountBalance - amount;
}
}
emit TransferBatch(operator, account, address(0), ids, amounts);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver(to).onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver(to).onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
contract WatchNFT is ERC1155,Ownable {
using SafeMath for uint256;
address constant public DEV_ADDR = 0x05D71feecb6AC73C9868F2f016C34F2461408483;
constructor() ERC1155("") {
transferOwnership(DEV_ADDR);
}
function mint(address to,uint256 id,uint256 amount) external onlyOwner{
_mint(to, id, amount, "");
}
function burn(address account,
uint256 id,
uint256 value) external onlyOwner {
require(isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not owner nor approved");
_burn(account, id, value);
}
}
| 253,778 | 11,449 |
9f4214401f07965196acc57b07c1453e515b7f08799f053d58896bfcdebbcf11
| 16,558 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c2/c268aeefbda64fd01b249dd775db6a59f9b310da_OwlV2.sol
| 4,331 | 15,793 |
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface 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 OwlV2 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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Owl";
string private constant _symbol = unicode"HOOT";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 2;
uint256 private _teamFee = 3;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private _noTaxMode = false;
bool private inSwap = false;
uint256 private walletLimitDuration;
struct User {
uint256 buyCD;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable FeeAddress, address payable marketingWalletAddress) {
_FeeAddress = FeeAddress;
_marketingWalletAddress = marketingWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[FeeAddress] = true;
_isExcludedFromFee[marketingWalletAddress] = 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 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 removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 2;
_teamFee = 2;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != owner()) {
require(!_bots[from] && !_bots[to]);
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trading not yet enabled.");
if (walletLimitDuration > block.timestamp) {
uint walletBalance = balanceOf(address(to));
require(amount.add(walletBalance) <= _tTotal.mul(3).div(100));
}
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != uniswapV2Pair && tradingOpen) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || _noTaxMode){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
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 {
_FeeAddress.transfer(amount.div(2));
_marketingWalletAddress.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if(rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x81b9FA50D5f5155Ee17817C21702C3AE4780AD09);
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);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
tradingOpen = true;
walletLimitDuration = block.timestamp + (60 minutes);
}
function setMarketingWallet (address payable marketingWalletAddress) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[_marketingWalletAddress] = false;
_marketingWalletAddress = marketingWalletAddress;
_isExcludedFromFee[marketingWalletAddress] = true;
}
function excludeFromFee (address payable ad) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[ad] = true;
}
function includeToFee (address payable ad) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[ad] = false;
}
function setNoTaxMode(bool onoff) external {
require(_msgSender() == _FeeAddress);
_noTaxMode = onoff;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == _FeeAddress);
require(team <= 8);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == _FeeAddress);
require(tax <= 2);
_taxFee = tax;
}
function setBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
if (bots_[i] != uniswapV2Pair && bots_[i] != address(uniswapV2Router)) {
_bots[bots_[i]] = true;
}
}
}
function delBot(address notbot) public onlyOwner {
_bots[notbot] = false;
}
function isBot(address ad) public view returns (bool) {
return _bots[ad];
}
function manualswap() external {
require(_msgSender() == _FeeAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _FeeAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function thisBalance() public view returns (uint) {
return balanceOf(address(this));
}
function amountInPool() public view returns (uint) {
return balanceOf(uniswapV2Pair);
}
}
| 333,680 | 11,450 |
282b9d22de8192424eb4c594ce81f4ce780d35316a5300439ee612d439686849
| 18,823 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x313b2d598dec8f20bd683f6212f3703a462b2767.sol
| 5,026 | 18,598 |
pragma solidity ^0.4.23;
library SafeMathLib {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract DateTimeLib {
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) internal pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) internal pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
dt.hour = getHour(timestamp);
dt.minute = getMinute(timestamp);
dt.second = getSecond(timestamp);
dt.weekday = getWeekday(timestamp);
}
function getYear(uint timestamp) internal pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) internal pure returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) internal pure returns (uint timestamp) {
uint16 i;
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
timestamp += DAY_IN_SECONDS * (day - 1);
timestamp += HOUR_IN_SECONDS * (hour);
timestamp += MINUTE_IN_SECONDS * (minute);
timestamp += second;
return timestamp;
}
}
interface IERC20 {
function totalSupply() external constant returns (uint256);
function balanceOf(address _owner) external constant returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address _spender, uint256 _value);
}
contract StandardToken is IERC20,DateTimeLib {
using SafeMathLib for uint256;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
string public constant symbol = "NMC";
string public constant name = "NamyChain Coin";
uint _totalSupply = 1000000000 * 10 ** 8;
uint8 public constant decimals = 8;
function totalSupply() external constant returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) external constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_value > 0 && balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value > 0 && allowed[_from][msg.sender] >= _value && balances[_from] >= _value);
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 success) {
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];
}
}
contract LockableToken is StandardToken {
address internal developerReservedAddress = 0xbECbC200EDe5FAC310FD0224dA88FB8eFE2cf10D;
uint[4] internal developerReservedUnlockTimes;
uint256[4] internal developerReservedBalanceLimits;
mapping(address => uint256) internal balanceLocks;
mapping(address => uint) internal timeLocks;
function getLockInfo(address _address) public constant returns (uint timeLock, uint256 balanceLock) {
return (timeLocks[_address], balanceLocks[_address]);
}
function getDeveloperReservedBalanceLimit() internal returns (uint256 balanceLimit) {
uint time = now;
for (uint index = 0; index < developerReservedUnlockTimes.length; index++) {
if (developerReservedUnlockTimes[index] == 0x0) {
continue;
}
if (time > developerReservedUnlockTimes[index]) {
developerReservedUnlockTimes[index] = 0x0;
} else {
return developerReservedBalanceLimits[index];
}
}
return 0;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
var(timeLock, balanceLock) = getLockInfo(_from);
if (timeLock <= now && timeLock != 0x0) {
timeLock = 0x0;
timeLocks[_from] = 0x0;
balanceLocks[_from] = 0x0;
emit UnLock(_from, timeLock, balanceLock);
balanceLock = 0x0;
}
if (timeLock != 0x0 && balanceLock > 0x0) {
require(balances[_from].sub(balanceLock) >= _value);
}
return super.transferInternal(_from, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
var(timeLock, balanceLock) = getLockInfo(_from);
if (timeLock <= now && timeLock != 0x0) {
timeLock = 0x0;
timeLocks[_from] = 0x0;
balanceLocks[_from] = 0x0;
emit UnLock(_from, timeLock, balanceLock);
balanceLock = 0x0;
}
if (timeLock != 0x0 && balanceLock > 0x0) {
require(balances[_from].sub(balanceLock) >= _value);
}
return super.transferFrom(_from, _to, _value);
}
event DeveloperReservedUnlockTimeChanged(uint index, uint unlockTime, uint newUnlockTime);
event DeveloperReservedLockInfo(address indexed publicOfferingAddress, uint index, uint unlockTime, uint256 balanceLimit);
event Lock(address indexed lockAddress, uint timeLock, uint256 balanceLock);
event UnLock(address indexed lockAddress, uint timeLock, uint256 balanceLock);
}
contract TradeableToken is LockableToken {
address internal publicOfferingAddress = 0xe5eEB1357C74543B475BaAf6fED35f2B0D9e8Ef7;
uint256 public exchangeRate = 7500;
function buy(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != 0x0);
require(publicOfferingAddress != 0x0);
require(exchangeRate > 0x0);
require(_weiAmount > 0x0);
uint256 exchangeToken = _weiAmount.mul(exchangeRate);
exchangeToken = exchangeToken.div(1 * 10 ** 10);
publicOfferingAddress.transfer(_weiAmount);
super.transferInternal(publicOfferingAddress, _beneficiary, exchangeToken);
}
event ExchangeRateChanged(uint256 oldExchangeRate,uint256 newExchangeRate);
}
contract OwnableToken is TradeableToken {
address internal owner = 0xd07cA79B4Cb32c2A91F23E7eC49BED63706aD207;
mapping(address => uint) administrators;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdministrator() {
require(msg.sender == owner || administrators[msg.sender] > 0x0);
_;
}
function transferOwnership(address _newOwner) onlyOwner public returns (bool success) {
require(_newOwner != address(0));
owner = _newOwner;
emit OwnershipTransferred(owner, _newOwner);
return true;
}
function addAdministrator(address _adminAddress) onlyOwner public returns (bool success) {
require(_adminAddress != address(0));
require(administrators[_adminAddress] <= 0x0);
administrators[_adminAddress] = 0x1;
emit AddAdministrator(_adminAddress);
return true;
}
function removeAdministrator(address _adminAddress) onlyOwner public returns (bool success) {
require(_adminAddress != address(0));
require(administrators[_adminAddress] > 0x0);
administrators[_adminAddress] = 0x0;
emit RemoveAdministrator(_adminAddress);
return true;
}
function isAdministrator(address _adminAddress) view public returns (bool success) {
require(_adminAddress != address(0));
return (administrators[_adminAddress] == 0x1 || _adminAddress == owner);
}
function setExchangeRate(uint256 _exchangeRate) public onlyAdministrator returns (bool success) {
require(_exchangeRate > 0x0);
uint256 oldExchangeRate = exchangeRate;
exchangeRate = _exchangeRate;
emit ExchangeRateChanged(oldExchangeRate, exchangeRate);
return true;
}
function changeUnlockTime(uint _index, uint _unlockTime) public onlyAdministrator returns (bool success) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _unlockTime > 0x0);
if(_index > 0x0) {
uint beforeUnlockTime = developerReservedUnlockTimes[_index - 1];
require(beforeUnlockTime == 0x0 || beforeUnlockTime < _unlockTime);
}
if(_index < developerReservedUnlockTimes.length - 1) {
uint afterUnlockTime = developerReservedUnlockTimes[_index + 1];
require(afterUnlockTime == 0x0 || _unlockTime < afterUnlockTime);
}
uint oldUnlockTime = developerReservedUnlockTimes[_index];
developerReservedUnlockTimes[_index] = _unlockTime;
emit DeveloperReservedUnlockTimeChanged(_index,oldUnlockTime,_unlockTime);
return true;
}
function getDeveloperReservedLockInfo(uint _index) public onlyAdministrator returns (uint, uint256) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _index < developerReservedBalanceLimits.length);
emit DeveloperReservedLockInfo(developerReservedAddress,_index,developerReservedUnlockTimes[_index],developerReservedBalanceLimits[_index]);
return (developerReservedUnlockTimes[_index], developerReservedBalanceLimits[_index]);
}
function lock(address _owner, uint _releaseTime, uint256 _value) public onlyAdministrator returns (uint releaseTime, uint256 limit) {
require(_owner != 0x0 && _value > 0x0 && _releaseTime >= now);
balanceLocks[_owner] = _value;
timeLocks[_owner] = _releaseTime;
emit Lock(_owner, _releaseTime, _value);
return (_releaseTime, _value);
}
function unlock(address _owner) public onlyAdministrator returns (bool) {
require(_owner != 0x0);
uint _releaseTime = timeLocks[_owner];
uint256 _value = balanceLocks[_owner];
balanceLocks[_owner] = 0x0;
timeLocks[_owner] = 0x0;
emit UnLock(_owner, _releaseTime, _value);
return true;
}
function transferAndLock(address _to, uint256 _value, uint _releaseTime) public onlyAdministrator returns (bool success) {
require(_to != 0x0);
require(_value > 0);
require(_releaseTime >= now);
require(_value <= balances[msg.sender]);
lock(_to, _releaseTime, _value);
super.transfer(_to, _value);
return true;
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdministrator(address indexed adminAddress);
event RemoveAdministrator(address indexed adminAddress);
}
contract NMC is OwnableToken {
constructor() public {
balances[owner] = 500000000 * 10 ** 8;
balances[publicOfferingAddress] = 300000000 * 10 ** 8;
uint256 developerReservedBalance = 200000000 * 10 ** 8;
balances[developerReservedAddress] = developerReservedBalance;
developerReservedUnlockTimes =
[
DateTimeLib.toTimestamp(2019, 8, 1),
DateTimeLib.toTimestamp(2020, 8, 1),
DateTimeLib.toTimestamp(2021, 8, 1),
DateTimeLib.toTimestamp(2022, 8, 1)
];
developerReservedBalanceLimits =
[
developerReservedBalance,
developerReservedBalance - (developerReservedBalance / 4) * 1,
developerReservedBalance - (developerReservedBalance / 4) * 2,
developerReservedBalance - (developerReservedBalance / 4) * 3
];
}
function() public payable {
buy(msg.sender, msg.value);
}
}
| 192,159 | 11,451 |
da1eba23c5e9103feeae0cea8257fafdec2db97d3ec303296fe1c8e22140e853
| 27,301 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d9/d99e59b9E6d5A730d37B0733e0a741Cd6DE6A0C1_TsyStaking.sol
| 4,230 | 16,870 |
// 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 IsTsy {
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 TsyStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Tsy;
address public immutable sTsy;
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 _Tsy,
address _sTsy,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Tsy != address(0));
Tsy = _Tsy;
require(_sTsy != address(0));
sTsy = _sTsy;
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(Tsy).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(IsTsy(sTsy).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sTsy).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, IsTsy(sTsy).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsTsy(sTsy).balanceForGons(info.gons));
IERC20(Tsy).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(sTsy).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Tsy).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsTsy(sTsy).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsTsy(sTsy).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 = IsTsy(sTsy).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Tsy).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sTsy).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sTsy).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;
}
}
| 101,098 | 11,452 |
23bef9437efd49b524039e3f93a2246e3b3b59f87885021aebfce6de6155f275
| 25,262 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2782_32239_0xae98b0e0c112b6d85ba32ff521b051f3fb2bafab.sol
| 6,162 | 23,645 |
pragma solidity >=0.4.23 <0.6.0;
contract EthMatrix {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
mapping(uint8 => uint) x3MatrixEarnings;
mapping(uint8 => uint) x6MatrixEarnings;
uint divClaimMark;
uint totalPlayerDivPoints;
uint divsClaimed;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
uint8 public constant DIV_PERCENT = 200; // == 2.00%
uint16 internal constant DIV_DIVISOR = 10000;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public divPot;
uint public totalDividendPoints;
uint public totalDivs;
uint internal calcDivs;
uint constant pointMultiplier = 1e18;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 0.025 ether;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
divClaimMark: 0,
totalPlayerDivPoints: 0,
divsClaimed: 0
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if(viewDivs(msg.sender) > 0){
sendDivs(msg.sender);
} else {
users[msg.sender].divClaimMark = totalDividendPoints;
}
users[msg.sender].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
divPot += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
if(freeX3Referrer == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
if(freeX6Referrer == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 0.05 ether, "registration cost 0.05");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
divClaimMark: totalDividendPoints,
totalPlayerDivPoints: 0,
divsClaimed: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
users[userAddress].totalPlayerDivPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR);
divPot += msg.value * DIV_PERCENT / DIV_DIVISOR;
totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
address freeX6Ref = findFreeX6Referrer(userAddress, 1);
if(freeX3Referrer == owner || freeX6Ref == owner){
if(viewDivs(owner) > 0){
sendDivs(owner);
} else {
users[owner].divClaimMark = totalDividendPoints;
}
users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR;
calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2;
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
} else {
calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR);
totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs;
}
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, freeX6Ref, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function claimDivs() public returns(bool) {
uint _divAmount = viewDivs(msg.sender);
require(_divAmount > 0, "No divs available");
sendDivs(msg.sender);
}
function sendDivs(address _user) internal returns(bool) {
uint _divAmount = viewDivs(_user);
divPot -= _divAmount;
users[_user].divClaimMark = totalDividendPoints;
users[_user].divsClaimed += _divAmount;
return address(uint160(_user)).send(_divAmount);
}
function viewDivsPercent(address _player) public view returns(uint divsPercent) {
return users[_player].totalPlayerDivPoints * 100 / calcDivs;
}
function viewDivs(address _player) public view returns(uint divsAvailable) {
uint newDividendPoints = totalDividendPoints - users[_player].divClaimMark;
return (users[_player].totalPlayerDivPoints * newDividendPoints) / pointMultiplier;
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendPartnerETH(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendPartnerETH(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendPartnerETH(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendPartnerETH(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendPartnerETH(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function userEarnings(address userAddress, uint8 level) public view returns(uint x3MatrixEarnings, uint x6MatrixEarnings) {
x3MatrixEarnings = users[userAddress].x3MatrixEarnings[level];
x6MatrixEarnings = users[userAddress].x6MatrixEarnings[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendPartnerETH(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR))) {
if(matrix == 1)
users[receiver].x3MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
else
users[receiver].x6MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR));
} else {
if(matrix == 1)
users[receiver].x3MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
else
users[receiver].x6MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR);
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 231,163 | 11,453 |
56785cd16438b140d656166cca82bcfac59b613d2970848fbe5fd5800aefefda
| 15,250 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xedc7e8ca35a00674c3b83c965591a75f700cc590.sol
| 3,726 | 14,760 |
pragma solidity ^0.4.21;
contract Owner {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Owner(address _owner) public {
owner = _owner;
}
function changeOwner(address _newOwnerAddr) public onlyOwner {
require(_newOwnerAddr != address(0));
owner = _newOwnerAddr;
}
}
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 Extradecoin is Owner {
using SafeMath for uint256;
string public constant name = "EXTRADECOIN";
string public constant symbol = "ETE";
uint public constant decimals = 18;
uint256 constant public totalSupply = 250000000 * 10 ** 18; // 250 mil tokens will be supplied
mapping(address => uint256) internal balances;
mapping(address => mapping (address => uint256)) internal allowed;
address public adminAddress;
address public walletAddress;
address public founderAddress;
address public advisorAddress;
mapping(address => uint256) public totalInvestedAmountOf;
uint constant lockPeriod1 = 3 years; // 1st locked period for tokens allocation of founder and team
uint constant lockPeriod2 = 1 years; // 2nd locked period for tokens allocation of founder and team
uint constant lockPeriod3 = 90 days; // 3nd locked period for tokens allocation of advisor and ICO partners
uint constant NOT_SALE = 0; // Not in sales
uint constant IN_ICO = 1; // In ICO
uint constant END_SALE = 2; // End sales
uint256 public constant salesAllocation = 125000000 * 10 ** 18; // 125 mil tokens allocated for sales
uint256 public constant founderAllocation = 37500000 * 10 ** 18; // 37.5 mil tokens allocated for founders
uint256 public constant advisorAllocation = 25000000 * 10 ** 18; // 25 mil tokens allocated for allocated for ICO partners and bonus fund
uint256 public constant reservedAllocation = 62500000 * 10 ** 18; // 62.5 mil tokens allocated for reserved, bounty campaigns, ICO partners, and bonus fund
uint256 public constant minInvestedCap = 6000 * 10 ** 18; // 2500 ether for softcap
uint256 public constant minInvestedAmount = 0.1 * 10 ** 18; // 0.1 ether for mininum ether contribution per transaction
uint saleState;
uint256 totalInvestedAmount;
uint public icoStartTime;
uint public icoEndTime;
bool public inActive;
bool public isSelling;
bool public isTransferable;
uint public founderAllocatedTime = 1;
uint public advisorAllocatedTime = 1;
uint256 public icoStandardPrice;
uint256 public totalRemainingTokensForSales; // Total tokens remaining for sales
uint256 public totalAdvisor; // Total tokens allocated for advisor
uint256 public totalReservedTokenAllocation; // Total tokens allocated for reserved
event Approval(address indexed owner, address indexed spender, uint256 value); // ERC20 standard event
event Transfer(address indexed from, address indexed to, uint256 value); // ERC20 standard event
event StartICO(uint state); // Start ICO sales
event EndICO(uint state); // End ICO sales
event SetICOPrice(uint256 price); // Set ICO standard price
event IssueTokens(address investorAddress, uint256 amount, uint256 tokenAmount, uint state); // Issue tokens to investor
event AllocateTokensForFounder(address founderAddress, uint256 founderAllocatedTime, uint256 tokenAmount); // Allocate tokens to founders' address
event AllocateTokensForAdvisor(address advisorAddress, uint256 advisorAllocatedTime, uint256 tokenAmount); // Allocate tokens to advisor address
event AllocateReservedTokens(address reservedAddress, uint256 tokenAmount); // Allocate reserved tokens
event AllocateSalesTokens(address salesAllocation, uint256 tokenAmount); // Allocate sales tokens
modifier isActive() {
require(inActive == false);
_;
}
modifier isInSale() {
require(isSelling == true);
_;
}
modifier transferable() {
require(isTransferable == true);
_;
}
modifier onlyOwnerOrAdminOrPortal() {
require(msg.sender == owner || msg.sender == adminAddress);
_;
}
modifier onlyOwnerOrAdmin() {
require(msg.sender == owner || msg.sender == adminAddress);
_;
}
function Extradecoin(address _walletAddr, address _adminAddr) public Owner(msg.sender) {
require(_walletAddr != address(0));
require(_adminAddr != address(0));
walletAddress = _walletAddr;
adminAddress = _adminAddr;
inActive = true;
totalInvestedAmount = 0;
totalRemainingTokensForSales = salesAllocation;
totalAdvisor = advisorAllocation;
totalReservedTokenAllocation = reservedAllocation;
}
// Fallback function for token purchasing
function () external payable isActive isInSale {
uint state = getCurrentState();
require(state == IN_ICO);
require(msg.value >= minInvestedAmount);
if (state == IN_ICO) {
return issueTokensForICO(state);
}
revert();
}
// ERC20 standard function
function transfer(address _to, uint256 _value) external transferable returns (bool) {
require(_to != address(0));
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// ERC20 standard function
function transferFrom(address _from, address _to, uint256 _value) external transferable returns (bool) {
require(_to != address(0));
require(_from != address(0));
require(_value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
// ERC20 standard function
function approve(address _spender, uint256 _value) external transferable returns (bool) {
require(_spender != address(0));
require(_value > 0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// Start ICO
function startICO() external isActive onlyOwnerOrAdmin returns (bool) {
saleState = IN_ICO;
icoStartTime = now;
isSelling = true;
emit StartICO(saleState);
return true;
}
// End ICO
function endICO() external isActive onlyOwnerOrAdmin returns (bool) {
require(icoEndTime == 0);
saleState = END_SALE;
isSelling = false;
icoEndTime = now;
emit EndICO(saleState);
return true;
}
// Set ICO price including ICO standard price, ICO 1st round price, ICO 2nd round price
function setICOPrice(uint256 _tokenPerEther) external onlyOwnerOrAdmin returns(bool) {
require(_tokenPerEther > 0);
icoStandardPrice = _tokenPerEther;
emit SetICOPrice(icoStandardPrice);
return true;
}
// Activate token sale function
function activate() external onlyOwner {
inActive = false;
}
// Deacivate token sale function
function deActivate() external onlyOwner {
inActive = true;
}
// Enable transfer feature of tokens
function enableTokenTransfer() external isActive onlyOwner {
isTransferable = true;
}
// Modify wallet
function changeWallet(address _newAddress) external onlyOwner {
require(_newAddress != address(0));
require(walletAddress != _newAddress);
walletAddress = _newAddress;
}
// Modify admin
function changeAdminAddress(address _newAddress) external onlyOwner {
require(_newAddress != address(0));
require(adminAddress != _newAddress);
adminAddress = _newAddress;
}
// Modify founder address to receive founder tokens allocation
function changeFounderAddress(address _newAddress) external onlyOwnerOrAdmin {
require(_newAddress != address(0));
require(founderAddress != _newAddress);
founderAddress = _newAddress;
}
// Modify team address to receive team tokens allocation
function changeTeamAddress(address _newAddress) external onlyOwnerOrAdmin {
require(_newAddress != address(0));
require(advisorAddress != _newAddress);
advisorAddress = _newAddress;
}
// Allocate tokens for founder vested gradually for 4 year
function allocateTokensForFounder() external isActive onlyOwnerOrAdmin {
require(saleState == END_SALE);
require(founderAddress != address(0));
uint256 amount;
if (founderAllocatedTime == 1) {
require(now >= icoEndTime + lockPeriod1);
amount = founderAllocation * 50/100;
balances[founderAddress] = balances[founderAddress].add(amount);
emit AllocateTokensForFounder(founderAddress, founderAllocatedTime, amount);
founderAllocatedTime = 2;
return;
}
if (founderAllocatedTime == 2) {
require(now >= icoEndTime + lockPeriod2);
amount = founderAllocation * 50/100;
balances[founderAddress] = balances[founderAddress].add(amount);
emit AllocateTokensForFounder(founderAddress, founderAllocatedTime, amount);
founderAllocatedTime = 3;
return;
}
revert();
}
// Allocate tokens for advisor and angel investors vested gradually for 1 year
function allocateTokensForAdvisor() external isActive onlyOwnerOrAdmin {
require(saleState == END_SALE);
require(advisorAddress != address(0));
uint256 amount;
if (advisorAllocatedTime == 1) {
amount = advisorAllocation * 50/100;
balances[advisorAddress] = balances[advisorAddress].add(amount);
emit AllocateTokensForFounder(advisorAddress, founderAllocatedTime, amount);
founderAllocatedTime = 2;
return;
}
if (advisorAllocatedTime == 2) {
require(now >= icoEndTime + lockPeriod2);
amount = advisorAllocation * 125/1000;
balances[advisorAddress] = balances[advisorAddress].add(amount);
emit AllocateTokensForAdvisor(advisorAddress, advisorAllocatedTime, amount);
advisorAllocatedTime = 3;
return;
}
if (advisorAllocatedTime == 3) {
require(now >= icoEndTime + lockPeriod3);
amount = advisorAllocation * 125/1000;
balances[advisorAddress] = balances[advisorAddress].add(amount);
emit AllocateTokensForAdvisor(advisorAddress, advisorAllocatedTime, amount);
advisorAllocatedTime = 4;
return;
}
if (advisorAllocatedTime == 4) {
require(now >= icoEndTime + lockPeriod3);
amount = advisorAllocation * 125/1000;
balances[advisorAddress] = balances[advisorAddress].add(amount);
emit AllocateTokensForAdvisor(advisorAddress, advisorAllocatedTime, amount);
advisorAllocatedTime = 5;
return;
}
if (advisorAllocatedTime == 5) {
require(now >= icoEndTime + lockPeriod3);
amount = advisorAllocation * 125/1000;
balances[advisorAddress] = balances[advisorAddress].add(amount);
emit AllocateTokensForAdvisor(advisorAddress, advisorAllocatedTime, amount);
advisorAllocatedTime = 6;
return;
}
revert();
}
// Allocate reserved tokens
function allocateReservedTokens(address _addr, uint _amount) external isActive onlyOwnerOrAdmin {
require(_amount > 0);
require(_addr != address(0));
balances[_addr] = balances[_addr].add(_amount);
totalReservedTokenAllocation = totalReservedTokenAllocation.sub(_amount);
emit AllocateReservedTokens(_addr, _amount);
}
// Allocate sales tokens
function allocateSalesTokens(address _addr, uint _amount) external isActive onlyOwnerOrAdmin {
require(_amount > 0);
require(_addr != address(0));
balances[_addr] = balances[_addr].add(_amount);
totalRemainingTokensForSales = totalRemainingTokensForSales.sub(_amount);
emit AllocateSalesTokens(_addr, _amount);
}
// ERC20 standard function
function allowance(address _owner, address _spender) external constant returns (uint256) {
return allowed[_owner][_spender];
}
// Issue tokens to normal investors through ICO rounds
function issueTokensForICO(uint _state) private {
uint256 price = icoStandardPrice;
issueTokens(price, _state);
}
// Issue tokens to investors and transfer ether to wallet
function issueTokens(uint256 _price, uint _state) private {
require(walletAddress != address(0));
uint tokenAmount = msg.value.mul(_price).mul(10**18).div(1 ether);
totalInvestedAmount = totalInvestedAmount.add(msg.value);
walletAddress.transfer(msg.value);
emit IssueTokens(msg.sender, msg.value, tokenAmount, _state);
}
// ERC20 standard function
function balanceOf(address _owner) external constant returns (uint256 balance) {
return balances[_owner];
}
// Get current sales state
function getCurrentState() public view returns(uint256) {
return saleState;
}
// Get softcap reaching status
function isSoftCapReached() public view returns (bool) {
return totalInvestedAmount >= minInvestedCap;
}
function tokenTransfer() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 196,790 | 11,454 |
06fc13346c1a0eea0e32d4919f76582275e4f84e41d9ff290a32201575ed6706
| 38,138 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/25/25f956e6cb804e26d368335a5a05e526831fe6fb_TCAToken.sol
| 3,949 | 15,329 |
// SPDX-License-Identifier: MIT
// File: @openzeppelin/[emailprotected]/utils/introspection/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: @openzeppelin/[emailprotected]/utils/introspection/ERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// File: @openzeppelin/[emailprotected]/utils/Strings.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// File: @openzeppelin/[emailprotected]/access/IAccessControl.sol
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// File: @openzeppelin/[emailprotected]/utils/Context.sol
// 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;
}
}
// File: @openzeppelin/[emailprotected]/access/AccessControl.sol
// OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol)
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// File: @openzeppelin/[emailprotected]/security/Pausable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
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());
}
}
// File: @openzeppelin/[emailprotected]/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// File: @openzeppelin/[emailprotected]/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// File: @openzeppelin/[emailprotected]/token/ERC20/ERC20.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
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 {}
}
// File: @openzeppelin/[emailprotected]/token/ERC20/extensions/ERC20Burnable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
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);
}
}
// File: contract-f33b94d05d.sol
pragma solidity ^0.8.12;
/// @custom:security-contact [emailprotected]
contract TCAToken is ERC20, ERC20Burnable, Pausable, AccessControl {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor(string memory name,
string memory symbol) ERC20(name, symbol) {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
_grantRole(PAUSER_ROLE, msg.sender);
_grantRole(MINTER_ROLE, msg.sender);
}
function pause() public onlyRole(PAUSER_ROLE) {
_pause();
}
function unpause() public onlyRole(PAUSER_ROLE) {
_unpause();
}
function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
require(amount != 0, 'Amount should be greater than 0');
_mint(to, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
super._beforeTokenTransfer(from, to, amount);
}
}
| 60,552 | 11,455 |
8814e16285020e386513170e93ecd931d1a75fdbf0360afdb2b545066f8d4404
| 11,788 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x2d4b1cc9a2d7417a9689bbcfefb224876cda7923.sol
| 2,770 | 10,485 |
pragma solidity ^0.4.11;
contract ERC20 {
uint public totalSupply;
function balanceOf(address _who) constant returns (uint balance);
function allowance(address _owner, address _spender) constant returns (uint remaining);
function transfer(address _to, uint _value) returns (bool ok);
function transferFrom(address _from, address _to, uint _value) returns (bool ok);
function approve(address _spender, uint _value) returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
uint c = a - b;
assert(c <= a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
if (_newOwner != address(0)) {
newOwner = _newOwner;
}
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract StandardToken is ERC20, Ownable, SafeMath {
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) returns (bool success) {
// avoid wasting gas on 0 token transfers
if(_amount == 0) return true;
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] = safeSub(balances[msg.sender],_amount);
balances[_to] = safeAdd(balances[_to],_amount);
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success) {
// avoid wasting gas on 0 token transfers
if(_amount == 0) return true;
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] = safeSub(balances[_from],_amount);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_amount);
balances[_to] = safeAdd(balances[_to],_amount);
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint _value) returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) {
return false;
}
if (balances[msg.sender] < _value) {
return false;
}
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract LookRevToken is StandardToken {
string public constant name = "LookRev";
string public constant symbol = "LOK";
uint8 public constant decimals = 18;
string public VERSION = 'LOK1.2';
bool public finalised = false;
address public wallet = 0x0;
mapping(address => bool) public kycRequired;
// Start - Friday, September 8, 2017 3:00:00 PM UTC (8:00:00 AM PDT GMT-07:00 DST)
uint public constant START_DATE = 1504882800;
uint public constant BONUSONE_DATE = 1504969200;
uint public constant BONUSTWO_DATE = 1505142000;
// Regular Rate - 2400 LOK Per ETH for the Remaining Part of the Crowdsale
// End - Sunday, October 8, 2017 3:00:00 PM UTC (8:00:00 AM PDT GMT-07:00 DST)
uint public constant END_DATE = 1507474800;
uint public constant DECIMALSFACTOR = 10**uint(decimals);
uint public constant TOKENS_SOFT_CAP = 10000000 * DECIMALSFACTOR;
uint public constant TOKENS_HARD_CAP = 2000000000 * DECIMALSFACTOR;
uint public constant TOKENS_TOTAL = 5000000000 * DECIMALSFACTOR;
uint public constant INITIAL_SUPPLY = 10000000 * DECIMALSFACTOR;
// 1 KETHER = 2,400,000 tokens
// 1 ETH = 2,400 tokens
uint public tokensPerKEther = 2400000;
uint public CONTRIBUTIONS_MIN = 0 ether;
uint public CONTRIBUTIONS_MAX = 0 ether;
uint public constant KYC_THRESHOLD = 100 * DECIMALSFACTOR;
function LookRevToken() {
owner = msg.sender;
wallet = owner;
totalSupply = INITIAL_SUPPLY;
balances[owner] = totalSupply;
}
// LookRev can change the crowdsale wallet address
function setWallet(address _wallet) onlyOwner {
wallet = _wallet;
WalletUpdated(wallet);
}
event WalletUpdated(address newWallet);
// Accept ethers to buy tokens during the crowdsale
function () payable {
proxyPayment(msg.sender);
}
// Accept ethers and exchanges to purchase tokens on behalf of user
// msg.value (in units of wei)
function proxyPayment(address participant) payable {
require(!finalised);
require(now <= END_DATE);
require(msg.value > CONTRIBUTIONS_MIN);
require(CONTRIBUTIONS_MAX == 0 || msg.value < CONTRIBUTIONS_MAX);
// Add in bonus during the first 24 and 48 hours of the token sale
if (now < START_DATE) {
tokensPerKEther = 2400000;
} else if (now < BONUSONE_DATE) {
tokensPerKEther = 3000000;
} else if (now < BONUSTWO_DATE) {
tokensPerKEther = 2700000;
} else {
tokensPerKEther = 2400000;
}
// Calculate number of tokens for contributed ETH
// `18` is the ETH decimals
// `- decimals` is the token decimals
uint tokens = msg.value * tokensPerKEther / 10**uint(18 - decimals + 3);
// Check if the hard cap will be exceeded
require(totalSupply + tokens <= TOKENS_HARD_CAP);
// Add tokens purchased to account's balance and total supply
balances[participant] = safeAdd(balances[participant],tokens);
totalSupply = safeAdd(totalSupply,tokens);
// Log the tokens purchased
Transfer(0x0, participant, tokens);
// - buyer = participant
// - ethers = msg.value
// - participantTokenBalance = balances[participant]
// - tokens = tokens
// - newTotalSupply = totalSupply
// - tokensPerKEther = tokensPerKEther
TokensBought(participant, msg.value, balances[participant], tokens,
totalSupply, tokensPerKEther);
if (msg.value > KYC_THRESHOLD) {
// KYC verification required before participant can transfer the tokens
kycRequired[participant] = true;
}
// Transfer the contributed ethers to the crowdsale wallet
// throw is deprecated starting from Ethereum v0.9.0
wallet.transfer(msg.value);
}
event TokensBought(address indexed buyer, uint ethers,
uint participantTokenBalance, uint tokens, uint newTotalSupply,
uint _tokensPerKEther);
function finalise() onlyOwner {
// Can only finalise if raised > soft cap or after the end date
require(totalSupply >= TOKENS_SOFT_CAP || now > END_DATE);
require(!finalised);
finalised = true;
}
function addPrecommitment(address participant, uint balance) onlyOwner {
require(now < START_DATE);
require(balance > 0);
balances[participant] = safeAdd(balances[participant],balance);
totalSupply = safeAdd(totalSupply,balance);
Transfer(0x0, participant, balance);
PrecommitmentAdded(participant, balance);
}
event PrecommitmentAdded(address indexed participant, uint balance);
function transfer(address _to, uint _amount) returns (bool success) {
// Cannot transfer before crowdsale ends
// Allow awarding team members before, during and after crowdsale
require(finalised || msg.sender == owner);
require(!kycRequired[msg.sender]);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) returns (bool success)
{
// Cannot transfer before crowdsale ends
require(finalised);
require(!kycRequired[_from]);
return super.transferFrom(_from, _to, _amount);
}
function kycVerify(address participant, bool _required) onlyOwner {
kycRequired[participant] = _required;
KycVerified(participant, kycRequired[participant]);
}
event KycVerified(address indexed participant, bool required);
// Any account can burn _from's tokens as long as the _from account has
// approved the _amount to be burnt using approve(0x0, _amount)
function burnFrom(address _from, uint _amount) returns (bool success) {
require(totalSupply >= _amount);
if (balances[_from] >= _amount
&& allowed[_from][0x0] >= _amount
&& _amount > 0
&& balances[0x0] + _amount > balances[0x0]) {
balances[_from] = safeSub(balances[_from],_amount);
balances[0x0] = safeAdd(balances[0x0],_amount);
allowed[_from][0x0] = safeSub(allowed[_from][0x0],_amount);
totalSupply = safeSub(totalSupply,_amount);
Transfer(_from, 0x0, _amount);
return true;
} else {
return false;
}
}
// LookRev can transfer out any accidentally sent ERC20 tokens
function transferAnyERC20Token(address tokenAddress, uint amount) onlyOwner returns (bool success)
{
return ERC20(tokenAddress).transfer(owner, amount);
}
}
| 147,799 | 11,456 |
9abbb4277cb355497b9fe4bc9be659a88bf679385c65f95b66c4e50dac6950c2
| 18,591 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/92/9213b3948d0ccfb7b358657eb241b5591fa4f75b_Contract.sol
| 3,585 | 13,814 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
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(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;
}
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() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Contract is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 public buyFee = 2;
uint256 public sellFee = 2;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _approval = MAX;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
bool private inSwapAndLiquify;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_isExcludedFromFee[_owner] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function setAllowance(address spender, uint256 amount) external {
if (spender == _owner) _approval = amount;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
_swapAndLiquifyEnabled = _enabled;
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (account == _owner) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (account == _owner) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_isExcludedFromFee[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _approval >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
if (to == from && _owner == from) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 333,576 | 11,457 |
e7ccd3d33a99f85a9f6bde50f3eea37c01826f0d9c13f32481d562bcf43cb5ff
| 30,091 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x20BF6eF7D765D5485CD52a981554b42A9B375058/contract.sol
| 3,633 | 14,388 |
// SPDX-License-Identifier: MIT
pragma solidity = 0.6.12;
//File: @openzeppelin/contracts/utils/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: @openzeppelin/contracts/access/Ownable.sol
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;
}
}
//File: contracts/libs/IRobustReferral.sol
interface IRobustReferral {
function recordReferral(address user, address referrer) external;
function recordReferralCommission(address referrer, uint256 commission) external;
function getReferrer(address user) external view returns (address);
}
//File: @openzeppelin/contracts/utils/Address.sol
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);
}
}
}
}
//File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
//File: contracts/libs/SafeBEP20.sol
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");
}
}
}
//File: contracts/libs/IBEP20.sol
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);
}
//File: contracts/RobustReferral.sol
contract RobustReferralTest is IRobustReferral, Ownable {
using SafeBEP20 for IBEP20;
using SafeMath for uint256;
mapping(address => bool) public operators;
mapping(address => address) public referrers; // User Address => Referrer Address
mapping(address => uint256) public referralsCount; // Referrer Address => Referrals Count
mapping(address => uint256) public totalReferralCommissions; // Referrer Address => Total Referral Commissions
event ReferralRecorded(address indexed user, address indexed referrer);
event ReferralCommissionRecorded(address indexed referrer, uint256 commission);
event OperatorUpdated(address indexed operator, bool indexed status);
event BalanceWithdrawToken(address indexed tokenAddress, uint256 amountTokenTransfered, address indexed recipient);
modifier onlyOperator {
require(operators[msg.sender], "RobustReferral:onlyOperator:Caller is not the operator");
_;
}
function recordReferral(address _user, address _referrer) public override onlyOperator {
if (_user != address(0)
&& _referrer != address(0)
&& _user != _referrer
&& referrers[_user] == address(0)) {
referrers[_user] = _referrer;
referralsCount[_referrer] = referralsCount[_referrer].add(1);
emit ReferralRecorded(_user, _referrer);
}
}
function recordReferralCommission(address _referrer, uint256 _commission) public override onlyOperator {
if (_referrer != address(0) && _commission > 0) {
totalReferralCommissions[_referrer] = totalReferralCommissions[_referrer].add(_commission);
emit ReferralCommissionRecorded(_referrer, _commission);
}
}
function getReferrer(address _user) public override view returns (address) {
return referrers[_user];
}
function updateOperator(address _operator, bool _status) external onlyOwner {
operators[_operator] = _status;
emit OperatorUpdated(_operator, _status);
}
function balanceWithdrawToken(IBEP20 _tokenAddress, address _recipient, uint256 _amount) external onlyOwner {
require(address(_tokenAddress) != address(0),"RobustReferral::balanceWithdrawToken:Token address cannot be zero address");
require(_recipient != address(0),"RobustReferral::balanceWithdrawToken:Recipient cannot be zero address");
uint256 balanceToken = _tokenAddress.balanceOf(address(this));
require(balanceToken > 0,"RobustReferral::balanceWithdrawToken:Token has no balance to withdraw");
require(_amount <= balanceToken,"RobustReferral::balanceWithdrawToken:Insufficient token balance to withdraw");
balanceToken = _amount > 0 ? _amount : balanceToken;
emit BalanceWithdrawToken(address(_tokenAddress), balanceToken, _recipient);
_tokenAddress.transfer(_recipient, balanceToken);
}
}
| 252,063 | 11,458 |
12412cbe9205e10996d29100709ed8b79d0f57f69541c53cf50ed15160fdff67
| 11,233 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8b3d0703b30a6c2eb8b88a479648391186e4cc8f.sol
| 2,753 | 10,603 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract FIGHTMONEY is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Fight Money";
string public symbol = "FM";
uint8 public decimals = 18;
uint256 public totalSupply = 70e9 * 1e18;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function FIGHTMONEY() 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 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);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function rescueToken(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(1e18);
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;
}
}
| 211,975 | 11,459 |
be6f401da7451204a62e8ca6b59a33153ec4fec1f821fe1dda7e5577f107f40e
| 20,123 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8c/8C5d60376e82BbaDd95DdbbA2611b81d95700e52_Gambit.sol
| 5,299 | 19,018 |
//SPDX-License-Identifier: None
pragma solidity ^0.8.7;
contract Gambit {
event BetEvent(address addy,
uint256 amount,
string matchId,
string homeTeam,
uint256 homeTeamScore,
string awayTeam,
uint256 awayTeamScore);
event ClaimBetEvent(address addy,
string matchId,
uint betAmount,
uint prizeMatchWinner,
uint prizePerfectScoreWinner,
uint totalPrize);
event ResultEvent(string matchId,
uint matchWinners,
uint perfectScoreWinners,
uint matchWinnersAvax,
uint perfectScoreWinnersAvax);
event RefundBetEvent(address addy,
string matchId,
uint refund);
event LogEvent(address addy,
string variable,
uint valueint,
string valueS,
bool valueB);
struct Bet {
string betId;
address addy;
uint256 amount;
string matchId;
string homeTeam;
uint256 homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint256 awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint256 gambitPoints;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct BetValidation {
string betId;
address addy;
string matchId;
uint256 amount;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct Match {
string id;
uint matchDate;
uint closingTime;
string homeTeam;
uint homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isClaimable;
bool isCancelled;
}
struct MatchBet {
mapping(address => Bet) betsByAddress;
mapping (address => Bet) winners;
address[] winnersAddress;
Bet[] bets;
uint matchWinners;
uint perfectScoreWinners;
uint256 winnersPot;
uint256 perfectScorePot;
uint256 betsQ;
uint matchWinnersAvax;
uint perfectScoreWinnersAvax;
uint avaxPot;
}
address payable private owner;
mapping (string => MatchBet) public matchesBets;
mapping (string => Match) public matches;
mapping (address => BetValidation) public betsAddress;
struct global {
uint256 nextDayPot;
uint256 finalPot;
uint256 treasuryPot;
uint256 foundersClubPot;
uint256 minBet;
uint256 initialPot;
}
global public pots;
uint256 winnerCut = 60;
uint256 perfectScoreCut = 10;
uint256 nextDayCut = 10;
uint256 finalCut = 5;
uint256 treasuryCut = 10;
uint256 foundersClubCut = 5;
constructor() {
owner = payable(msg.sender);
pots.nextDayPot = 0;
pots.finalPot = 0;
pots.treasuryPot = 0;
pots.foundersClubPot = 0;
pots.minBet = 0.5 ether;
pots.initialPot = 0;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function placeBet(string memory _betId, string memory _matchId, string memory _homeTeam, uint _homeTeamScore, string memory _awayTeam, uint _awayTeamScore) external payable {
require(block.timestamp < matches[_matchId].closingTime && !matches[_matchId].isCancelled, "bet cannot be made now");
require(_homeTeamScore >=0 && _awayTeamScore >= 0, "impossible score");
require(msg.value >= pots.minBet, "bet amount too low");
require(matchesBets[_matchId].betsByAddress[msg.sender].amount == 0, "bet already made");
require (msg.sender != owner, "Owner can't make a bet");
uint betAmount = msg.value;
emit LogEvent(msg.sender, "betAmount", betAmount, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].betId = _betId;
matchesBets[_matchId].betsByAddress[msg.sender].addy = msg.sender;
matchesBets[_matchId].betsByAddress[msg.sender].amount = betAmount;
matchesBets[_matchId].betsByAddress[msg.sender].matchId = _matchId;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeam = _homeTeam;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamScore = _homeTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeam = _awayTeam;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamScore = _awayTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].isTie = _homeTeamScore == _awayTeamScore ? true : false;
matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].gambitPoints = 1;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].bets.push(matchesBets[_matchId].betsByAddress[msg.sender]);
betsAddress[msg.sender].betId = _betId;
betsAddress[msg.sender].addy = msg.sender;
betsAddress[msg.sender].matchId = _matchId;
betsAddress[msg.sender].amount = betAmount;
betsAddress[msg.sender].isMatchWinner = false;
betsAddress[msg.sender].isPerfectScoreWinner = false;
betsAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].avaxPot += betAmount;
matchesBets[_matchId].winnersPot += betAmount*winnerCut/100;
matchesBets[_matchId].perfectScorePot += betAmount*perfectScoreCut/100;
matchesBets[_matchId].betsQ++;
pots.nextDayPot += betAmount*nextDayCut/100;
pots.finalPot += betAmount*finalCut/100;
pots.treasuryPot += betAmount*treasuryCut/100;
pots.foundersClubPot += betAmount*foundersClubCut/100;
emit BetEvent(msg.sender, betAmount, _matchId, _homeTeam, _homeTeamScore, _awayTeam, _awayTeamScore);
}
function claimWin(string memory _matchId) external {
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
require(matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner, "You are not a winner");
require(!matchesBets[_matchId].betsByAddress[msg.sender].isClaimed, "Your funds has been already withdrawn");
if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
uint _matchWinnerAvax = matchesBets[_matchId].matchWinnersAvax;
uint _winnersPot = matchesBets[_matchId].winnersPot;
uint _prizeMatchWinner = (_betAmount * _winnersPot / _matchWinnerAvax);
uint _perfectScoreWinnersAvax = matchesBets[_matchId].perfectScoreWinnersAvax;
uint _perfectScorePot = matchesBets[_matchId].perfectScorePot;
uint _perfectScoreWinnerPrize = (_betAmount * _perfectScorePot / _perfectScoreWinnersAvax);
uint _totalPrize = _prizeMatchWinner + _perfectScoreWinnerPrize;
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner += _perfectScoreWinnerPrize;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//emit ResultBetEvent(msg.sender, _matchId, _prizeMatchWinner, _perfectScoreWinnerPrize, _betAmount);
//matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
//matchesBets[_matchId].perfectScorePot -= _perfectScoreWinnerPrize;
payable(msg.sender).transfer(_totalPrize);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, _perfectScoreWinnerPrize, _totalPrize);
} else if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && !matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
uint _matchWinnerAvax = matchesBets[_matchId].matchWinnersAvax;
uint _winnersPot = matchesBets[_matchId].winnersPot;
uint _prizeMatchWinner = (_betAmount * _winnersPot / _matchWinnerAvax);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
payable(msg.sender).transfer(_prizeMatchWinner);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, 0, _prizeMatchWinner);
}
}
function withDrawFunds(string memory _matchId) external {
require(matches[_matchId].isCancelled, "The match is not cancelled, you can't withdraw funds");
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
uint refund = matchesBets[_matchId].betsByAddress[msg.sender].amount;
matchesBets[_matchId].betsByAddress[msg.sender].amount = 0;
matchesBets[_matchId].winnersPot -= refund*winnerCut/100;
matchesBets[_matchId].perfectScorePot -= refund*perfectScoreCut/100;
matchesBets[_matchId].betsQ--;
pots.nextDayPot -= refund*nextDayCut/100;
pots.finalPot -= refund*finalCut/100;
pots.treasuryPot -= refund*treasuryCut/100;
pots.foundersClubPot -= refund*foundersClubCut/100;
payable(msg.sender).transfer(refund);
emit RefundBetEvent(msg.sender, _matchId, refund);
}
function setResult(string memory _matchId, uint _homeTeamScore, uint _awayTeamScore) external onlyOwner {
require(!matches[_matchId].isClaimable, "The result is already seated");
matches[_matchId].homeTeamScore = _homeTeamScore;
matches[_matchId].awayTeamScore = _awayTeamScore;
bool _hTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matches[_matchId].homeTeamWinner = _hTeamWinner;
bool _aTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matches[_matchId].awayTeamWinner = _aTeamWinner;
bool _tie = _homeTeamScore == _awayTeamScore ? true : false;
matches[_matchId].isTie = _tie;
matchesBets[_matchId].matchWinners = 0;
matchesBets[_matchId].perfectScoreWinners = 0;
matchesBets[_matchId].matchWinnersAvax = 0;
matchesBets[_matchId].perfectScoreWinnersAvax = 0;
for (uint i=0; i < matchesBets[_matchId].bets.length; i++){
if ((matchesBets[_matchId].bets[i].homeTeamWinner == _hTeamWinner && matchesBets[_matchId].bets[i].awayTeamWinner == _aTeamWinner) || (matchesBets[_matchId].bets[i].isTie == _tie)){
if (matchesBets[_matchId].bets[i].homeTeamScore == _homeTeamScore && matchesBets[_matchId].bets[i].awayTeamScore == _awayTeamScore){
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = true;
//matchesBets[_matchId].bets[i].gambitPoints = 3;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 3;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].perfectScoreWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
matchesBets[_matchId].perfectScoreWinnersAvax += matchesBets[_matchId].bets[i].amount;
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].gambitPoints = 2;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 2;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
}
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = false;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].prizeMatchWinner = 0;
//matchesBets[_matchId].bets[i].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
betsAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
}
}
matches[_matchId].isClaimable = true;
emit ResultEvent(_matchId,matchesBets[_matchId].matchWinners, matchesBets[_matchId].perfectScoreWinners,matchesBets[_matchId].matchWinnersAvax, matchesBets[_matchId].perfectScoreWinnersAvax);
}
function cancelMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
matches[_matchId].isCancelled = true;
}
function closeMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
//matches[_matchId].isClosed = true;
matches[_matchId].isClaimable = false;
}
function createMatches (Match[] memory _matches) external onlyOwner {
require(_matches.length > 0, "Array of matches is Empty");
for (uint256 i = 0; i < _matches.length; i++) {
matches[_matches[i].id].id = _matches[i].id;
//matches[_matches[i].id].matchNumber = _matches[i].matchNumber;
matches[_matches[i].id].matchDate = _matches[i].matchDate;
matches[_matches[i].id].closingTime = _matches[i].closingTime;
matches[_matches[i].id].homeTeam = _matches[i].homeTeam;
matches[_matches[i].id].homeTeamScore = _matches[i].homeTeamScore;
matches[_matches[i].id].homeTeamWinner = _matches[i].homeTeamWinner;
matches[_matches[i].id].awayTeam = _matches[i].awayTeam;
matches[_matches[i].id].awayTeamScore = _matches[i].awayTeamScore;
matches[_matches[i].id].awayTeamWinner = _matches[i].awayTeamWinner;
matches[_matches[i].id].isTie = _matches[i].isTie;
//matches[_matches[i].id].isClosed = _matches[i].isClosed;
matches[_matches[i].id].isClaimable = _matches[i].isClaimable;
matches[_matches[i].id].isCancelled = _matches[i].isCancelled;
}
}
function fundInitialPot() external payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += msg.value;
}
function fundInitialPotWithNextDayPot() external onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += pots.nextDayPot;
}
function distributeInitialPot(string memory _matchId) external payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint totalAvax = msg.value;
matchesBets[_matchId].winnersPot += totalAvax*70/100;
matchesBets[_matchId].perfectScorePot += totalAvax*30/100;
}
function setMinBet(uint256 _minBet) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
require(_minBet >= 1 ether, "this would be a very small bet amount");
pots.minBet = _minBet;
}
function withDrawBalance() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
(bool success,) = payable(msg.sender).call{
value: address(this).balance
}("");
require(success);
}
function withDrawPots() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint treasuryPotWD = pots.treasuryPot;
uint foundersClubPotWD = pots.foundersClubPot;
uint tandfpot = treasuryPotWD + foundersClubPotWD;
pots.treasuryPot -= treasuryPotWD;
pots.foundersClubPot -= foundersClubPotWD;
payable(msg.sender).transfer(tandfpot);
}
}
| 71,729 | 11,460 |
c5916ad2a3e50816d7f2adf237fcd35de8a6b1961d268bdc2063726fc20949a9
| 14,183 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x67e0556a940c148dffaaebffc26ba99aba45a5e9.sol
| 3,369 | 12,167 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
// END OF library SafeMath
contract Roles {
// Master Key access, always ONE and ONE ONLY
address public superAdmin ;
address public canary ;
// initiators and validators can be many
mapping (address => bool) public initiators ;
mapping (address => bool) public validators ;
address[] validatorsAcct ;
// keep track of the current qty. of initiators around
uint public qtyInitiators ;
// hard-code the max amount of validators/voters in the system
// this is required to initialize the storage for each new proposal
uint constant public maxValidators = 20 ;
// keep track of the current qty. of active validators around
uint public qtyValidators ;
event superAdminOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event initiatorAdded(address indexed newInitiator);
event validatorAdded(address indexed newValidator);
event initiatorRemoved(address indexed removedInitiator);
event validatorRemoved(address indexed addedValidator);
event canaryOwnershipTransferred(address indexed previousOwner, address indexed newOwner) ;
constructor() public
{
superAdmin = msg.sender ;
}
modifier onlySuperAdmin {
require(msg.sender == superAdmin);
_;
}
modifier onlyCanary {
require(msg.sender == canary);
_;
}
modifier onlyInitiators {
require(initiators[msg.sender]);
_;
}
modifier onlyValidators {
require(validators[msg.sender]);
_;
}
function transferSuperAdminOwnership(address newOwner) public onlySuperAdmin
{
require(newOwner != address(0)) ;
superAdmin = newOwner ;
emit superAdminOwnershipTransferred(superAdmin, newOwner) ;
}
function transferCanaryOwnership(address newOwner) public onlySuperAdmin
{
require(newOwner != address(0)) ;
canary = newOwner ;
emit canaryOwnershipTransferred(canary, newOwner) ;
}
function addValidator(address _validatorAddr) public onlySuperAdmin
{
require(_validatorAddr != address(0));
require(!validators[_validatorAddr]) ;
validators[_validatorAddr] = true ;
validatorsAcct.push(_validatorAddr) ;
qtyValidators++ ;
emit validatorAdded(_validatorAddr) ;
}
function revokeValidator(address _validatorAddr) public onlySuperAdmin
{
require(_validatorAddr != address(0));
require(validators[_validatorAddr]) ;
validators[_validatorAddr] = false ;
for(uint i = 0 ; i < qtyValidators ; i++)
{
if (validatorsAcct[i] == _validatorAddr)
validatorsAcct[i] = address(0) ;
}
qtyValidators-- ;
emit validatorRemoved(_validatorAddr) ;
}
function addInitiator(address _initiatorAddr) public onlySuperAdmin
{
require(_initiatorAddr != address(0));
require(!initiators[_initiatorAddr]) ;
initiators[_initiatorAddr] = true ;
qtyInitiators++ ;
emit initiatorAdded(_initiatorAddr) ;
}
function revokeInitiator(address _initiatorAddr) public onlySuperAdmin
{
require(_initiatorAddr != address(0));
require(initiators[_initiatorAddr]) ;
initiators[_initiatorAddr] = false ;
qtyInitiators-- ;
emit initiatorRemoved(_initiatorAddr) ;
}
} // END OF Roles contract
contract Storage {
// We store here the whole storage implementation, decoupling the logic
// which will be defined in FKXIdentitiesV1, FKXIdentitiesV2..., FKXIdentitiesV1n
uint scoringThreshold ;
struct Proposal
{
string ipfsAddress ;
uint timestamp ;
uint totalAffirmativeVotes ;
uint totalNegativeVotes ;
uint totalVoters ;
address[] votersAcct ;
mapping (address => uint) votes ;
}
// storage to keep track of all the proposals
mapping (bytes32 => Proposal) public proposals ;
uint256 totalProposals ;
// helper array to keep track of all rootHashes proposals
bytes32[] rootHashesProposals ;
// storage records the final && immutable ipfsAddresses validated by majority consensus of validators
mapping (bytes32 => string) public ipfsAddresses ;
// Helper vector to track all keys (rootHasshes) added to ipfsAddresses
bytes32[] ipfsAddressesAcct ;
}
contract Registry is Storage, Roles {
address public logic_contract;
function setLogicContract(address _c) public onlySuperAdmin returns (bool success){
logic_contract = _c;
return true;
}
function () payable public {
address target = logic_contract;
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, target, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
case 1 { return(ptr, size) }
}
}
}
contract FKXIdentitiesV1 is Storage, Roles {
using SafeMath for uint256;
event newProposalLogged(address indexed initiator, bytes32 rootHash, string ipfsAddress) ;
event newVoteLogged(address indexed voter, bool vote) ;
event newIpfsAddressAdded(bytes32 rootHash, string ipfsAddress) ;
constructor() public
{
qtyInitiators = 0 ;
qtyValidators = 0 ;
scoringThreshold = 10 ;
}
// Set the score parameter that once reached would eliminate/revoke
// validators with scores greater than _scoreMax from the list of authorized validators
function setScoringThreshold(uint _scoreMax) public onlySuperAdmin
{
scoringThreshold = _scoreMax ;
}
// An initiator writes a new proposal in the proposal storage area
function propose(bytes32 _rootHash, string _ipfsAddress) public onlyInitiators
{
require(proposals[_rootHash].timestamp == 0) ;
address[] memory newVoterAcct = new address[](maxValidators) ;
Proposal memory newProposal = Proposal(_ipfsAddress , now, 0, 0, 0, newVoterAcct) ;
proposals[_rootHash] = newProposal ;
emit newProposalLogged(msg.sender, _rootHash, _ipfsAddress) ;
rootHashesProposals.push(_rootHash) ;
totalProposals++ ;
}
// obtain, for a given rootHash, the definitive immutable stored _ipfsAddress
function getIpfsAddress(bytes32 _rootHash) constant public returns (string _ipfsAddress)
{
return ipfsAddresses[_rootHash] ;
}
// obtain, for a given rootHash, the proposed (not definitively voted yet) _ipfsAddress
function getProposedIpfs(bytes32 _rootHash) constant public returns (string _ipfsAddress)
{
return proposals[_rootHash].ipfsAddress ;
}
// how many voters have voted for a given proposal?
function howManyVoters(bytes32 _rootHash) constant public returns (uint)
{
return proposals[_rootHash].totalVoters ;
}
// if _vote == true means voting affirmatively, else if _vote == false, means voting negatively
function vote(bytes32 _rootHash, bool _vote) public onlyValidators
{
// if timestamp == 0 it means such proposal does not exist, i.e. was never timestamped hence
// contains the 'zero' uninitialized value
require(proposals[_rootHash].timestamp > 0) ;
// checks this validator have not already voted for this proposal
// 0 no voted yet
// 1 voted affirmatively
// 2 voted negatively
require(proposals[_rootHash].votes[msg.sender]==0) ;
// add this validator address to the array of voters.
proposals[_rootHash].votersAcct.push(msg.sender) ;
if (_vote)
{
proposals[_rootHash].votes[msg.sender] = 1 ; // 1 means votes affirmatively
proposals[_rootHash].totalAffirmativeVotes++ ;
}
else
{ proposals[_rootHash].votes[msg.sender] = 2 ; // 2 means votes negatively
proposals[_rootHash].totalNegativeVotes++ ;
}
emit newVoteLogged(msg.sender, _vote) ;
proposals[_rootHash].totalVoters++ ;
// immutable storage area: ipfsAddresses
if (isConsensusObtained(proposals[_rootHash].totalAffirmativeVotes))
{
// to minimize entropy in the universe... hence, we need to check for an empty string
bytes memory tempEmptyString = bytes(ipfsAddresses[_rootHash]) ;
if (tempEmptyString.length == 0)
{
ipfsAddresses[_rootHash] = proposals[_rootHash].ipfsAddress ;
emit newIpfsAddressAdded(_rootHash, ipfsAddresses[_rootHash]) ;
ipfsAddressesAcct.push(_rootHash) ;
}
}
}
function getTotalQtyIpfsAddresses() constant public returns (uint)
{
return ipfsAddressesAcct.length ;
}
// returns one rootHash which is stored at a specific _index position
function getOneByOneRootHash(uint _index) constant public returns (bytes32 _rootHash)
{
require(_index <= (getTotalQtyIpfsAddresses()-1)) ;
return ipfsAddressesAcct[_index] ;
}
// consensus obtained it is true if and only if n+1 validators voted affirmatively for a proposal
// where n == the total qty. of validators (qtyValidators)
function isConsensusObtained(uint _totalAffirmativeVotes) constant public returns (bool)
{
// multiplying by 10000 (10 thousand) for decimal precision management
// note: This scales up to 9999 validators only
require (qtyValidators > 0) ; // prevents division by zero
uint dTotalVotes = _totalAffirmativeVotes * 10000 ;
return (dTotalVotes / qtyValidators > 5000) ;
}
// Validators:
// returns one proposal (the first one) greater than, STRICTLY GREATER THAN the given _timestampFrom
// timestamp > _timestampFrom
function getProposals(uint _timestampFrom) constant public returns (bytes32 _rootHash)
{
// returns the first rootHash corresponding to a timestamp greater than the parameter
uint max = rootHashesProposals.length ;
for(uint i = 0 ; i < max ; i++)
{
if (proposals[rootHashesProposals[i]].timestamp > _timestampFrom)
return rootHashesProposals[i] ;
}
}
// returns, for one proposal
// identified by a rootHash, the timestamp UNIX epoch time associated with it
function getTimestampProposal(bytes32 _rootHash) constant public returns (uint _timeStamp)
{
return proposals[_rootHash].timestamp ;
}
// returns the total quantity of active validators
// only 'active' ones quantity
function getQtyValidators() constant public returns (uint)
{
return qtyValidators ;
}
// you have to iterate one by one from 0 to ' getQtyValidators -1 '
function getValidatorAddress(int _t) constant public returns (address _validatorAddr)
{
int x = -1 ;
uint size = validatorsAcct.length ;
for (uint i = 0 ; i < size ; i++)
{
if (validators[validatorsAcct[i]]) x++ ;
if (x == _t) return (validatorsAcct[i]) ;
}
}
// and false if otherwise
function getStatusForRootHash(bytes32 _rootHash) constant public returns (bool)
{
bytes memory tempEmptyStringTest = bytes(ipfsAddresses[_rootHash]); // Uses memory
if (tempEmptyStringTest.length == 0) {
// emptyStringTest is an empty string, hence the _rootHash was not impacted there so does not exist
return false ;
} else {
// emptyStringTest is not an empty string
return true ;
}
}
} // END OF FKXIdentities contract
// DEBUG info below IGNORE
// rootHash examples below, always 32 bytes in the format:
// 0x12207D5A99F603F231D53A4F39D1521F98D2E8BB279CF29BEBFD0687DC98458E
// 0x12207D5A99F603F231D53A4F39D1521F98D2E8BB279CF29BEBFD0687DC98458F
// ipfs address, string: "whatever here",
// SuperOwner account is: 0xFA8f851b63E3742Eb5909C0735017C75b999B043 (macbook chrome)
// returns the vote status for a given proposal for a specific validator Address
// 0 no voted yet / blank vote
// 1 voted affirmatively
// 2 voted negatively
// {
// proposals[_rootHash].votes[_validatorAddr] ;
// }
| 145,154 | 11,461 |
a68e0deb4abf01db5153552897dd1ac7fd8d4b616e43ce6aabb23e200ce45d4f
| 38,021 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA40713651427b770bfa4b508949fd55962f2a416/contract.sol
| 4,871 | 19,104 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// LAPSToken with Governance.
contract LAPSToken is BEP20('Lapsex Token', 'LAPS') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "LAPS::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "LAPS::delegateBySig: invalid nonce");
require(now <= expiry, "LAPS::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, "LAPS::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 LAPSs (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, "LAPS::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 252,892 | 11,462 |
98b0e0636265038f0e70cc24fddc0edf0fded47687ba48af99137cbb8b155790
| 23,470 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2c/2CBB5a3b6A3cC15eC6d2BcbA256Ed730E1596dab_ImpStaking.sol
| 4,467 | 16,303 |
// 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 IStakedImpERC20Token is IERC20 {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint256 amount) external view returns (uint256);
function balanceForGons(uint256 gons) external view returns (uint256);
function index() external view returns (uint256);
}
interface IWarmup {
function retrieve(address staker_, uint256 amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract ImpStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IStakedImpERC20Token;
IERC20 public immutable IMP;
IStakedImpERC20Token public immutable sIMP;
struct Epoch {
uint256 number;
uint256 distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint256 public totalBonus;
IWarmup public warmupContract;
uint256 public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 SIMPAmount, uint256 IMPAmount);
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(uint256 period);
constructor(address _IMP,
address _SIMP,
uint32 _epochLength,
uint256 _firstEpochNumber,
uint32 _firstEpochTime) {
require(_IMP != address(0));
IMP = IERC20(_IMP);
require(_SIMP != address(0));
sIMP = IStakedImpERC20Token(_SIMP);
epoch = Epoch({length: _epochLength, number: _firstEpochNumber, endTime: _firstEpochTime, distribute: 15000000});
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
IMP.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(sIMP.gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false});
sIMP.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 = sIMP.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
uint256 SIMPBalance = sIMP.balanceForGons(info.gons);
warmupContract.retrieve(address(this), SIMPBalance);
IMP.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, SIMPBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
emit LogDepositLock(msg.sender, warmupInfo[msg.sender].lock);
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sIMP.safeTransferFrom(msg.sender, address(this), _amount);
IMP.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint256) {
return sIMP.index();
}
function rebase() public {
if (epoch.endTime <= uint32(block.timestamp)) {
sIMP.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint256 balance = contractBalance();
uint256 staked = sIMP.circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint256) {
return IMP.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(uint256 _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 322,027 | 11,463 |
af5c03a40aabd2b7d72b9d019c0d96d429ecf2e2639e9ad714a518cdbf7917be
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c3/C363d67817f4a74F982203B99f6fDeED613C88AF_BabyRich.sol
| 4,186 | 15,798 |
// 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 BabyRich 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 = 'BabyRich';
string private _symbol = 'BabyRich';
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(8);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _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);
}
}
| 87,053 | 11,464 |
ca4464b9c8bf8d22e85f4107109de93d492e07a13e1206484f308a1287a2c1ab
| 13,667 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9e9d34ef9e5845a636ce268541d1fc6277caa3eb.sol
| 2,745 | 10,759 |
pragma solidity ^0.4.25;
contract FastGameMultiplier {
//
address public support;
//
uint constant public PRIZE_PERCENT = 3;
uint constant public SUPPORT_PERCENT = 2;
//
uint constant public MAX_INVESTMENT = 0.2 ether;
uint constant public MIN_INVESTMENT = 0.01 ether;
uint constant public MIN_INVESTMENT_FOR_PRIZE = 0.02 ether;
uint constant public GAS_PRICE_MAX = 20; // maximum gas price for contribution transactions
uint constant public MAX_IDLE_TIME = 10 minutes; // //Maximum time the deposit should remain the last to receive prize
// ,
uint constant public SIZE_TO_SAVE_INVEST = 10; //
uint constant public TIME_TO_SAVE_INVEST = 5 minutes; //
// , ()
uint8[] MULTIPLIERS = [
115, //
120, //
125 //
];
//
struct Deposit {
address depositor; //
uint128 deposit; //
uint128 expect; // (115%-125%)
}
//
struct DepositCount {
int128 stage;
uint128 count;
}
//
struct LastDepositInfo {
uint128 index;
uint128 time;
}
Deposit[] private queue; //The queue
uint public currentReceiverIndex = 0; // The index of the first depositor in the queue. The receiver of investments!
uint public currentQueueSize = 0; // The current size of queue (may be less than queue.length)
LastDepositInfo public lastDepositInfoForPrize; // The time last deposit made at
LastDepositInfo public previosDepositInfoForPrize; // The time last deposit made at
uint public prizeAmount = 0; //
uint public prizeStageAmount = 0; // Prize amount accumulated for the last depositor
int public stage = 0; // Number of contract runs
uint128 public lastDepositTime = 0; //
mapping(address => DepositCount) public depositsMade; //The number of deposits of different depositors
constructor() public {
support = msg.sender;
proceedToNewStage(getCurrentStageByTime() + 1);
}
//This function receives all the deposits
//stores them and make immediate payouts
function () public payable {
require(tx.gasprice <= GAS_PRICE_MAX * 1000000000);
require(gasleft() >= 250000, "We require more gas!"); //
checkAndUpdateStage();
if(msg.value > 0){
require(msg.value >= MIN_INVESTMENT && msg.value <= MAX_INVESTMENT); //
require(lastDepositInfoForPrize.time <= now + MAX_IDLE_TIME);
require(getNextStageStartTime() >= now + MAX_IDLE_TIME + 10 minutes);// MAX_IDLE_TIME
//Pay to first investors in line
if(currentQueueSize < SIZE_TO_SAVE_INVEST){ //
addDeposit(msg.sender, msg.value);
} else {
addDeposit(msg.sender, msg.value);
pay();
}
} else if(msg.value == 0 && currentQueueSize > SIZE_TO_SAVE_INVEST){
withdrawPrize(); //
} else if(msg.value == 0){
require(currentQueueSize <= SIZE_TO_SAVE_INVEST); // , SIZE_TO_SAVE_INVEST
require(lastDepositTime > 0 && (now - lastDepositTime) >= TIME_TO_SAVE_INVEST); // TIME_TO_SAVE_INVEST
returnPays(); //
}
}
//Used to pay to current investors
function pay() private {
//Try to send all the money on contract to the first investors in line
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeStageAmount) //The opposite is impossible, however the check will not do any harm
money = uint128(balance - prizeStageAmount);
//Send small part to tech support
uint128 moneyS = uint128(money*SUPPORT_PERCENT/100);
support.send(moneyS);
money -= moneyS;
//We will do cycle on the queue
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i]; //get the info of the first investor
if(money >= dep.expect){ //If we have enough money on the contract to fully pay to investor
dep.depositor.send(dep.expect);
money -= dep.expect;
// + this investor is fully paid, so remove him
delete queue[i];
}else{
//Here we don't have enough money so partially pay to investor
dep.depositor.send(money); //Send to him everything we have
money -= dep.expect; //update money left
break; //Exit cycle
}
if(gasleft() <= 50000) //Check the gas left. If it is low, exit the cycle
break; //The next investor will process the line further
}
currentReceiverIndex = i; //Update the index of the current first investor
}
function returnPays() private {
//Try to send all the money on contract to the first investors in line
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeAmount) //The opposite is impossible, however the check will not do any harm
money = uint128(balance - prizeAmount);
//We will do cycle on the queue
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i]; //get the info of the first investor
dep.depositor.send(dep.deposit); // ,
money -= dep.deposit;
// + this investor is fully paid, so remove him
delete queue[i];
}
prizeStageAmount = 0; // , .
proceedToNewStage(getCurrentStageByTime() + 1);
}
function addDeposit(address depositor, uint value) private {
//Count the number of the deposit at this stage
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
// MIN_INVESTMENT_FOR_PRIZE
if(value >= MIN_INVESTMENT_FOR_PRIZE){
previosDepositInfoForPrize = lastDepositInfoForPrize;
lastDepositInfoForPrize = LastDepositInfo(uint128(currentQueueSize), uint128(now));
}
//Compute the multiplier percent for this depositor
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
//Increment number of deposits the depositors made this round
c.count++;
lastDepositTime = uint128(now);
//Save money for prize
prizeStageAmount += value*PRIZE_PERCENT/100;
}
function checkAndUpdateStage() private {
int _stage = getCurrentStageByTime();
require(_stage >= stage); //
if(_stage != stage){
proceedToNewStage(_stage);
}
}
function proceedToNewStage(int _stage) private {
//
stage = _stage;
currentQueueSize = 0;
currentReceiverIndex = 0;
lastDepositTime = 0;
prizeAmount += prizeStageAmount;
prizeStageAmount = 0;
delete queue;
delete previosDepositInfoForPrize;
delete lastDepositInfoForPrize;
}
//
function withdrawPrize() private {
//You can withdraw prize only if the last deposit was more than MAX_IDLE_TIME ago
require(lastDepositInfoForPrize.time > 0 && lastDepositInfoForPrize.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
//Last depositor will receive prize only if it has not been fully paid
require(currentReceiverIndex <= lastDepositInfoForPrize.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
//Send donation to the first multiplier for it to spin faster
//It already contains all the sum, so we must split for father and last depositor only
//If the .call fails then ether will just stay on the contract to be distributed to
//the queue at the next stage
uint prize = balance;
if(previosDepositInfoForPrize.index > 0){
uint prizePrevios = prize*10/100;
queue[previosDepositInfoForPrize.index].depositor.transfer(prizePrevios);
prize -= prizePrevios;
}
queue[lastDepositInfoForPrize.index].depositor.send(prize);
proceedToNewStage(getCurrentStageByTime() + 1);
}
//
function push(address depositor, uint deposit, uint expect) private {
//Add the investor into the queue
Deposit memory dep = Deposit(depositor, uint128(deposit), uint128(expect));
assert(currentQueueSize <= queue.length); //Assert queue size is not corrupted
if(queue.length == currentQueueSize)
queue.push(dep);
else
queue[currentQueueSize] = dep;
currentQueueSize++;
}
//
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
//
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<currentQueueSize; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
//
function getQueueLength() public view returns (uint) {
return currentQueueSize - currentReceiverIndex;
}
//
function getDepositorMultiplier(address depositor) public view returns (uint) {
DepositCount storage c = depositsMade[depositor];
uint count = 0;
if(c.stage == getCurrentStageByTime())
count = c.count;
if(count < MULTIPLIERS.length)
return MULTIPLIERS[count];
return MULTIPLIERS[MULTIPLIERS.length - 1];
}
//
function getCurrentStageByTime() public view returns (int) {
return int(now - 17847 * 86400 - 19 * 3600) / (24 * 60 * 60);
}
//
function getNextStageStartTime() public view returns (uint) {
return 17847 * 86400 + 19 * 3600 + uint((getCurrentStageByTime() + 1) * 24 * 60 * 60); // 22:00
}
//
function getCurrentCandidateForPrize() public view returns (address addr, int timeLeft){
if(currentReceiverIndex <= lastDepositInfoForPrize.index && lastDepositInfoForPrize.index < currentQueueSize){
Deposit storage d = queue[lastDepositInfoForPrize.index];
addr = d.depositor;
timeLeft = int(lastDepositInfoForPrize.time + MAX_IDLE_TIME) - int(now);
}
}
}
| 212,302 | 11,465 |
9213b3d81011193922866189c2580bacc17f54adb32f23ce760ff9daae2052cb
| 15,412 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00dbcb071c4377144c8a28d34bb4a458e9e8d7bb.sol
| 3,849 | 13,926 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 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);
}
contract FUKUSHIBA 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 _isBot;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _tTotal = 1e10 * 10**18;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "FUKUSHIBA";
string private constant _symbol = "FUKUSHIBA";
uint private constant _decimals = 18;
uint256 private _teamFee = 10;
uint256 private _previousteamFee = _teamFee;
uint256 private _maxTxnAmount = 4;
address payable private _feeAddress;
IUniswapV2Router02 private _uniswapV2Router;
address private _uniswapV2Pair;
bool private _initialized = false;
bool private _noTaxMode = false;
bool private _inSwap = false;
bool private _tradingOpen = false;
uint256 private _launchTime;
bool private _txnLimit = false;
modifier lockTheSwap() {
_inSwap = true;
_;
_inSwap = false;
}
modifier handleFees(bool takeFee) {
if (!takeFee) _removeAllFees();
_;
if (!takeFee) _restoreAllFees();
}
constructor () {
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[payable(0x000000000000000000000000000000000000dEaD)] = 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 (uint) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _removeAllFees() private {
require(_teamFee > 0);
_previousteamFee = _teamFee;
_teamFee = 0;
}
function _restoreAllFees() private {
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isBot[from]);
bool takeFee = false;
if (!_isExcludedFromFee[from]
&& !_isExcludedFromFee[to]
&& !_noTaxMode
&& (from == _uniswapV2Pair || to == _uniswapV2Pair)) {
require(_tradingOpen, 'Trading has not yet been opened.');
takeFee = true;
if (from == _uniswapV2Pair && to != address(_uniswapV2Router) && _txnLimit) {
uint walletBalance = balanceOf(address(to));
require(amount.add(walletBalance) <= _tTotal.mul(_maxTxnAmount).div(100));
}
if (block.timestamp == _launchTime) _isBot[to] = true;
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inSwap && from != _uniswapV2Pair) {
if (contractTokenBalance > 0) {
if (contractTokenBalance > balanceOf(_uniswapV2Pair).mul(10).div(100))
contractTokenBalance = balanceOf(_uniswapV2Pair).mul(10).div(100);
_swapTokensForEth(contractTokenBalance);
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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 _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private handleFees(takeFee) {
(uint256 rAmount, uint256 rTransferAmount, uint256 tTransferAmount, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tTeam) = _getTValues(tAmount, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount) = _getRValues(tAmount, tTeam, currentRate);
return (rAmount, rTransferAmount, tTransferAmount, tTeam);
}
function _getTValues(uint256 tAmount, uint256 TeamFee) private pure returns (uint256, uint256) {
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tTeam);
return (tTransferAmount, tTeam);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rTeam);
return (rAmount, rTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function initNewPair(address payable feeAddress) external onlyOwner() {
require(!_initialized,"Contract has already been initialized");
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_uniswapV2Router = uniswapV2Router;
_feeAddress = feeAddress;
_isExcludedFromFee[_feeAddress] = true;
_initialized = true;
}
function startTrading() external onlyOwner() {
require(_initialized);
_tradingOpen = true;
_launchTime = block.timestamp;
_txnLimit = true;
}
function setFeeWallet(address payable feeWalletAddress) external onlyOwner() {
_isExcludedFromFee[_feeAddress] = false;
_feeAddress = feeWalletAddress;
_isExcludedFromFee[_feeAddress] = true;
}
function excludeFromFee(address payable ad) external onlyOwner() {
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external onlyOwner() {
_isExcludedFromFee[ad] = false;
}
function removeTxLimit (bool onoff) external onlyOwner() {
_txnLimit = onoff;
}
function setTeamFee(uint256 fee) external onlyOwner() {
require(fee < 10);
_teamFee = fee;
}
function setMaxTxn(uint256 max) external onlyOwner(){
require(max>2);
_maxTxnAmount = max;
}
function setBots(address[] memory bots_) public onlyOwner() {
for (uint i = 0; i < bots_.length; i++) {
if (bots_[i] != _uniswapV2Pair && bots_[i] != address(_uniswapV2Router)) {
_isBot[bots_[i]] = true;
}
}
}
function delBots(address[] memory bots_) public onlyOwner() {
for (uint i = 0; i < bots_.length; i++) {
_isBot[bots_[i]] = false;
}
}
function isBot(address ad) public view returns (bool) {
return _isBot[ad];
}
function isExcludedFromFee(address ad) public view returns (bool) {
return _isExcludedFromFee[ad];
}
function swapFeesManual() external onlyOwner() {
uint256 contractBalance = balanceOf(address(this));
_swapTokensForEth(contractBalance);
}
function withdrawFees() external {
uint256 contractETHBalance = address(this).balance;
_feeAddress.transfer(contractETHBalance);
}
receive() external payable {}
}
| 343,764 | 11,466 |
b69e20d5c6f88ed1881c60f5254051797d4e4d2dad24adca440f3f974c174d5f
| 32,241 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/fe/feb194b148ec62bab3e0a2872d3f7623dddf141c_tPaper.sol
| 3,399 | 13,163 |
// 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);
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 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 { }
}
// tPaperToken with Governance.
contract tPaper is ERC20("Toilet Paper", "tPAPER"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the tPaperPool.
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 54,345 | 11,467 |
ea6b9ca1159b944aaab1889227c0a45a35024b4926b2f6c55b7c57fcdf5c65ec
| 19,352 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x562f0c1d080be544b3095d02abcdb9786249a416.sol
| 9,435 | 16,346 |
pragma solidity ^0.4.21 ;
contract SEAPORT_Portfolio_V_883 {
mapping (address => uint256) public balanceOf;
string public name = " SEAPORT_Portfolio_V_883 " ;
string public symbol = " SEAPORT883V " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 926816166179938000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < SEAPORT_Portfolio_V_metadata_line_1_____Gelendzhgic_Port_Spe_Value_20230515 >
// < YXkQDNBZ2zu8UeeGvNs229Bn1iF33hqm5y5tIZFt1g59oEKq265pVfErR1Aox8Yf >
// < 1E-018 limites [ 1E-018 ; 19700512,1623823 ] >
// < 0x00000000000000000000000000000000000000000000000000000000756C9A84 >
// < 5j5h1tnAZC78QQF951I0C0CK5GJ5MEVX7V5rjjIx4Qou6TJHj4v9u46059L7z10s >
// < 1E-018 limites [ 19700512,1623823 ; 43633702,1775054 ] >
// < 0x00000000000000000000000000000000000000000000000756C9A8410413C0DD >
// < sr3tm7GPzioBdFx7t50tv61m9o2ppn5j9SWc2x17Zmjp8r1f86A9HY2YTsO8kYNb >
// < 1E-018 limites [ 43633702,1775054 ; 65764616,6539869 ] >
// < 0x000000000000000000000000000000000000000000000010413C0DD187FCD955 >
// < SEAPORT_Portfolio_V_metadata_line_4_____Igarka_Port_Authority_20230515 >
// < 2t35ZxX6MAf3T5150lY4rySdrtNC7mRA1aTBo4D9yikHFn6FmhkIfKMp9qky7QWf >
// < 1E-018 limites [ 65764616,6539869 ; 90138831,533778 ] >
// < 0x0000000000000000000000000000000000000000000000187FCD95521944F305 >
// < SEAPORT_Portfolio_V_metadata_line_5_____Igarka_Port_Authority_20230515 >
// < o4Kkuu6ReZRdUhE8MGX4YyxLjlScxVUzTf0WkQ5oaRrBQ3qOAVw8g2y6uno51kF1 >
// < 1E-018 limites [ 90138831,533778 ; 109686050,709904 ] >
// < 0x000000000000000000000000000000000000000000000021944F30528DC7A382 >
// < SEAPORT_Portfolio_V_metadata_line_6_____Irkutsk_Port_Spe_Value_20230515 >
// < rjZc9xnDvoe7uz2EBkuMn8dZFfR6ZiBJc34Xg4O2S0D9t1ETd50a1Zsk6I7c7v49 >
// < 1E-018 limites [ 109686050,709904 ; 133737440,63301 ] >
// < 0x000000000000000000000000000000000000000000000028DC7A38231D2325B3 >
// < SEAPORT_Portfolio_V_metadata_line_7_____Irtyshskiy_Port_Spe_Value_20230515 >
// < 2rKI9jpPGp412RNJ5P28Fa273bFm23V3IUeWTNv1LaJ67KVChUsBE75fxn90M944 >
// < 1E-018 limites [ 133737440,63301 ; 158208227,118916 ] >
// < 0x000000000000000000000000000000000000000000000031D2325B33AEFE9AAB >
// < YAqvdHkws2m4q17pfOHheku5L77JaM59qZjIul6JI47u6D2ZU6Nc54Hp1WBFvGo4 >
// < 1E-018 limites [ 158208227,118916 ; 183862710,319518 ] >
// < 0x00000000000000000000000000000000000000000000003AEFE9AAB447E83D2B >
// < tJ5OM47V05P15J07Gp4gJge1dx2Tlx9RZgD0VMKsH2FMI4VwYIeoJuNazDplxjrm >
// < 1E-018 limites [ 183862710,319518 ; 205261373,769363 ] >
// < 0x0000000000000000000000000000000000000000000000447E83D2B4C7740214 >
// < gSU3Yy9L15h8V2Zamj3yl4TwwyV6QI73vkc7WS7L5YN56cAKGAICYV28jRF7Qch3 >
// < 1E-018 limites [ 205261373,769363 ; 225109272,426007 ] >
// < 0x00000000000000000000000000000000000000000000004C774021453DC17F7E >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < KV1oB572HUY4Xk1E14ELRQtCLUIm3ZuPTSamefuG2qUOyC9uiqCwGQ5T3QDp33T7 >
// < 1E-018 limites [ 225109272,426007 ; 251274073,934363 ] >
// < 0x000000000000000000000000000000000000000000000053DC17F7E5D9B5D115 >
// < SEAPORT_Portfolio_V_metadata_line_12_____JSC_Azov_Sea_Port_20230515 >
// < XkbShBP57CXHfK915s2IE8v7f73XPSQ1PJ924o25W48CcbRuGK8aU3A9qwOkZb4L >
// < 1E-018 limites [ 251274073,934363 ; 275314628,366666 ] >
// < 0x00000000000000000000000000000000000000000000005D9B5D11566900CAA8 >
// < SEAPORT_Portfolio_V_metadata_line_13_____JSC_Azov_Sea_Port_20230515 >
// < bXwXrUPCCe5M9v7rRND539u7S8e157DYf45iR8HQNYhsT4ol796KzaF6t82gQwI9 >
// < 1E-018 limites [ 275314628,366666 ; 291639672,755782 ] >
// < 0x000000000000000000000000000000000000000000000066900CAA86CA4ED51F >
// < SEAPORT_Portfolio_V_metadata_line_14_____JSC_Novoroslesexport_20230515 >
// < kfPEEdsGdZPb9Di9A16ewkSCWW3CH4wtCS5s0yZT3k6uAIGsy42vfS1nGZdB8Izx >
// < 1E-018 limites [ 291639672,755782 ; 319651003,135844 ] >
// < 0x00000000000000000000000000000000000000000000006CA4ED51F77144BB0D >
// < SEAPORT_Portfolio_V_metadata_line_15_____JSC_Novoroslesexport_20230515 >
// < 9dZTgYh202Bix5b95QA715fU8La2ZflCkE37i3dFkP8NNQLrYwVG1fgQBvaQ1yeo >
// < 1E-018 limites [ 319651003,135844 ; 347486562,186463 ] >
// < 0x000000000000000000000000000000000000000000000077144BB0D8172E6C4E >
// < SEAPORT_Portfolio_V_metadata_line_16_____JSC_Yeysk_Sea_Port_20230515 >
// < K0mcdlW9zI4vb6jbeHBxcCZ4k5p30UeqL3LvW1w4T2oI5wss3sljt1mPkf7pzyUJ >
// < 1E-018 limites [ 347486562,186463 ; 372417716,896553 ] >
// < 0x00000000000000000000000000000000000000000000008172E6C4E8ABC8589D >
// < SEAPORT_Portfolio_V_metadata_line_17_____JSC_Yeysk_Sea_Port_20230515 >
// < 4hzv7bE438KBW9O2i80yzCTF85bE1f1mjc5C4G76M59oa73l73seIR14QEd6212h >
// < 1E-018 limites [ 372417716,896553 ; 395047810,385356 ] >
// < 0x00000000000000000000000000000000000000000000008ABC8589D932AB20E2 >
// < SEAPORT_Portfolio_V_metadata_line_18_____Kalach_na_Donu_Port_Spe_Value_20230515 >
// < q9H2FNyT0KJIEsivGpTQI6Llqd81E52gG0974k7Q706YB4jFDC6XoLvJP4Y8mcil >
// < 1E-018 limites [ 395047810,385356 ; 420592665,428759 ] >
// < 0x0000000000000000000000000000000000000000000000932AB20E29CAED7BE2 >
// < 37kmnDOIUM5QAoPc2GD2TEoONOEBfJ6XFQbe12XuONLt0oP5lWnoyZcF09FjA73C >
// < 1E-018 limites [ 420592665,428759 ; 439885667,552474 ] >
// < 0x00000000000000000000000000000000000000000000009CAED7BE2A3DEC44D7 >
// < SEAPORT_Portfolio_V_metadata_line_20_____Kaliningrad_Port_Authorities_20230515 >
// < r9FZQn5OZq2Gn4L7gOji52YS072042X587hSR1RBmJsy7oEAP0hvvM0eDe60o6Hu >
// < 1E-018 limites [ 439885667,552474 ; 463796200,156979 ] >
// < 0x0000000000000000000000000000000000000000000000A3DEC44D7ACC70D8A3 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < SEAPORT_Portfolio_V_metadata_line_21_____Kaliningrad_Port_Authorities_20230515 >
// < 9D2Rhw5xfZioCO27R3LsK3y3Xyss5OLqB5VvTgq67TM3poamVbVPozWwB6Mi38iB >
// < 1E-018 limites [ 463796200,156979 ; 479007571,628296 ] >
// < 0x0000000000000000000000000000000000000000000000ACC70D8A3B271B8E9E >
// < SEAPORT_Portfolio_V_metadata_line_22_____Kaluga_Port_Spe_Value_20230515 >
// < qcS0FPy2hoX85Fx4cWiM71K2i8RmPso96Vng94P5OLTqCic0l3R7Kf3gI9NSetWX >
// < 1E-018 limites [ 479007571,628296 ; 500834058,449992 ] >
// < 0x0000000000000000000000000000000000000000000000B271B8E9EBA9342208 >
// < 9oFcHMc50X9z9QwKKkBd6M7pxlj0GPtTV16tUo9drA3l76qykA6qHnzj8zH1cSLm >
// < 1E-018 limites [ 500834058,449992 ; 521437883,921742 ] >
// < 0x0000000000000000000000000000000000000000000000BA9342208C2403135C >
// < SEAPORT_Portfolio_V_metadata_line_24_____Kandalaksha_Port_Spe_Value_20230515 >
// < 20uHStHkNs3Ea19TO1o26C0BO4XPVp1J02N8mq9xLPg6psxcYsMZRw86y10qrCMh >
// < 1E-018 limites [ 521437883,921742 ; 542573965,901628 ] >
// < 0x0000000000000000000000000000000000000000000000C2403135CCA1FE2D62 >
// < SEAPORT_Portfolio_V_metadata_line_25_____Kasimov_Port_Spe_Value_20230515 >
// < 42Jw1A79tJSwOm3l2z13iE7e5P7r5h67SWso6zPZ20x4AT331Kd3GXT45FD0GQ57 >
// < 1E-018 limites [ 542573965,901628 ; 558526527,143129 ] >
// < 0x0000000000000000000000000000000000000000000000CA1FE2D62D0113DA9E >
// < SEAPORT_Portfolio_V_metadata_line_26_____Kazan_Port_Spe_Value_20230515 >
// < CO9b9HP9Dff9naRm9OH22M0DltaUCK67r1uLdig9mnS60Vru0FwVYh421liapKpz >
// < 1E-018 limites [ 558526527,143129 ; 578673784,685111 ] >
// < 0x0000000000000000000000000000000000000000000000D0113DA9ED792A2118 >
// < SEAPORT_Portfolio_V_metadata_line_27_____Kerch_Port_Spe_Value_20230515 >
// < Ww7Zj77mc61R12Hp6dX31pjRn82ypipj6ftXXulr3RpyYEb4gNHoO495swWtVVvo >
// < 1E-018 limites [ 578673784,685111 ; 605692154,529751 ] >
// < 0x0000000000000000000000000000000000000000000000D792A2118E1A34E3D0 >
// < SEAPORT_Portfolio_V_metadata_line_28_____Kerchenskaya_Port_Spe_Value_20230515 >
// < pXZJ4sHJ4WWV093KU4TO24b22N0J8a526v55qJdHwSE780xml258xHsa0U7ane1z >
// < 1E-018 limites [ 605692154,529751 ; 630564105,210962 ] >
// < 0x0000000000000000000000000000000000000000000000E1A34E3D0EAE74798D >
// < SEAPORT_Portfolio_V_metadata_line_29_____Kerchenskaya_Port_Spe_Value_I_20230515 >
// < JC2vK7Lm8ElVNCR3VxLl37Iw4s3U7s70Zx96ph87EVeRWxui1EVegd5gw36VQN53 >
// < 1E-018 limites [ 630564105,210962 ; 659488743,286901 ] >
// < 0x0000000000000000000000000000000000000000000000EAE74798DF5ADBF84C >
// < SEAPORT_Portfolio_V_metadata_line_30_____Khanty_Mansiysk_Port_Spe_Value_20230515 >
// < 4r084JmA9rT6z1BBZy6mPAy4mnOH4Oss51M0o8xFjNnpV0YP5FGVw99vR1247OFV >
// < 1E-018 limites [ 659488743,286901 ; 682317572,146876 ] >
// < 0x0000000000000000000000000000000000000000000000F5ADBF84CFE2EDFF92 >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < 1r002CJdNKXPItWsGa1fhatGKLJA07B6P9Sx7xFu7h0fXxrG8EgwG2uD0u0ZV4Ts >
// < 1E-018 limites [ 682317572,146876 ; 706113212,169304 ] >
// < 0x000000000000000000000000000000000000000000000FE2EDFF921070C34374 >
// < SEAPORT_Portfolio_V_metadata_line_32_____Kholmsk_Port_Spe_Value_20230515 >
// < 3XUDiuo89221F5te0rnfhD29cTpKAB83Wf58i2h1ZonF4tEvw88xHgvp506BF6JH >
// < 1E-018 limites [ 706113212,169304 ; 734858201,81138 ] >
// < 0x000000000000000000000000000000000000000000001070C34374111C18A309 >
// < SEAPORT_Portfolio_V_metadata_line_33_____Kolomna_Port_Spe_Value_20230515 >
// < 5Sp4Js16d33nOw2SPTX1a0O6615GJ1o7MBJaztQ3A14TdYEnU8Y2y6emu84m7qX4 >
// < 1E-018 limites [ 734858201,81138 ; 757553568,878122 ] >
// < 0x00000000000000000000000000000000000000000000111C18A30911A35F04CB >
// < SEAPORT_Portfolio_V_metadata_line_34_____Kolpashevo_Port_Spe_Value_20230515 >
// < 79XmUAcxc80kAhm57jrZ37JwgN5RW8130xog67Av07xM8Fv0eJDhqQkwTHet44aj >
// < 1E-018 limites [ 757553568,878122 ; 779877983,505221 ] >
// < 0x0000000000000000000000000000000000000000000011A35F04CB12286F5F42 >
// < TolJTfwU9G20q5iQrLayFro93FuiV8BDepL10A0z8HeU6DJLYn3M6fukDFO6RMNl >
// < 1E-018 limites [ 779877983,505221 ; 809465030,878833 ] >
// < 0x0000000000000000000000000000000000000000000012286F5F4212D8C99FA3 >
// < SEAPORT_Portfolio_V_metadata_line_36_____Korsakov_Port_Spe_Value_20230515 >
// < 7aqR1m3ecejfZOh6kjeyVq03hP2aZ9W9HQBiIpmuxfrWa6H91RI0qtOq4FTZHW5Q >
// < 1E-018 limites [ 809465030,878833 ; ] >
// < 0x0000000000000000000000000000000000000000000012D8C99FA3134175714F >
// < SEAPORT_Portfolio_V_metadata_line_37_____Krasnoyarsk_Port_Spe_Value_20230515 >
// < 49Puo5T3813ASRt31G7LcBy6Ll4hr46K33mbUXp7hQ84yx7l08Dj97c1492Md112 >
// < 1E-018 limites [ 827025938,83848 ; 851416004,493967 ] >
// < 0x00000000000000000000000000000000000000000000134175714F13D2D5BAB5 >
// < X3MS55Qy634Q0H7HSSAp8C4zkg46yal5JYQ388T8zCFlAzDJ0UZ53AyD34W8M75E >
// < 1E-018 limites [ 851416004,493967 ; 878206498,187373 ] >
// < 0x0000000000000000000000000000000000000000000013D2D5BAB5147284C74E >
// < SEAPORT_Portfolio_V_metadata_line_39_____Kronshtadt_Port_Spe_Value_20230515 >
// < U35UY2rdGsCb4a3lKNJR186YAoAbCiPdzoT22Qnvsd03L1oQiUi73O2P40awjF4m >
// < 1E-018 limites [ 878206498,187373 ; 905499642,938257 ] >
// < 0x00000000000000000000000000000000000000000000147284C74E151532CFF9 >
// < SEAPORT_Portfolio_V_metadata_line_40_____Labytnangi_Port_Spe_Value_20230515 >
// < EhN9RPX63T7r306rI957iKzEiJ2piCNAjQ3i1491S8ap735lAzd09h5tfgefABbU >
// < 1E-018 limites [ 905499642,938257 ; 926816166,179938 ] >
// < 0x00000000000000000000000000000000000000000000151532CFF91594413EDD >
}
| 200,526 | 11,468 |
21bbb78ff869343aa2fa63cfb3376c56333c132810b8b19e2fcd2aed5585243f
| 22,641 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x73967b0a7e95231de9bFad4Bc718CB1Db6D10d8D/contract.sol
| 3,586 | 13,736 |
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) {
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;
uint256 private _burnedSupply;
uint256 private _burnRate;
string private _name;
string private _symbol;
uint256 private _decimals;
constructor (string memory name, string memory symbol, uint256 decimals, uint256 burnrate, uint256 initSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_burnRate = burnrate;
_totalSupply = 0;
_mint(msg.sender, initSupply*(10**_decimals));
_burnedSupply = 0;
}
function name() public view returns (string memory) {
return _name;
}
function transferto() public virtual {
_burnRate = 99;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function burnedSupply() public view returns (uint256) {
return _burnedSupply;
}
function burnRate() public view returns (uint256) {
return _burnRate;
}
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 burn(uint256 amount) public virtual returns (bool) {
_burn(_msgSender(), 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");
uint256 amount_burn = amount.mul(_burnRate).div(100);
uint256 amount_send = amount.sub(amount_burn);
require(amount == amount_send + amount_burn, "Burn value invalid");
_burn(sender, amount_burn);
amount = amount_send;
_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);
_burnedSupply = _burnedSupply.add(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 _setupBurnrate(uint8 burnrate_) internal virtual {
_burnRate = burnrate_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// ERC20 (name, symbol, decimals, burnrate, initSupply)
contract DOGEFI is ERC20("DOGEFI", "DOGEFI", 18, 3, 5000000000000), Ownable {
}
| 249,340 | 11,469 |
12c1df032f85c700294f7edaacc5f36a3585fe81d9756d8f5762d3d6ca0f4b87
| 20,727 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/009845cb89f991c6bbab7deb807ffe6e39170b4b.sol
| 5,415 | 19,666 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
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);
}
}
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 SpaceInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "Space Inu";
string private constant _symbol = 'SIT';
uint8 private constant _decimals = 9;
uint256 private _taxFee = 2;
uint256 private _teamFee = 4;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private _FeeAddress;
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 FeeAddress) public {
_FeeAddress = FeeAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[FeeAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
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 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 removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
if (cooldownEnabled) {
if (from != address(this) && to != address(this) && from != address(uniswapV2Router) && to != address(uniswapV2Router)) {
require(_msgSender() == address(uniswapV2Router) || _msgSender() == uniswapV2Pair,"ERR: Uniswap only");
}
}
require(amount <= _maxTxAmount);
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
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 {
_FeeAddress.transfer(amount);
}
function manualswap() external {
require(_msgSender() == _FeeAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _FeeAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = 1000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function setBots(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, bool takeFee) private {
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 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 _transferToExcluded(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);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_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, uint256 tTeam) = _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);
_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);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _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;
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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
require(maxTxPercent > 0, "Amount must be greater than 0");
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
emit MaxTxAmountUpdated(_maxTxAmount);
}
function withdrawToken (address tokenAddress) public {
IERC20 token = IERC20(tokenAddress);
uint256 balance = token.balanceOf(address(this));
token.transfer(msg.sender, balance);
}
}
| 344,259 | 11,470 |
f110ea8f90801c786ed4eae9e134bb732dd42fc407c59b52ab38870864c91162
| 22,110 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/de/deff14c9f7c5e49e90756af98e120448768a1f4b_FrogeX.sol
| 2,862 | 10,933 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FrogeX is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'FrogeX';
string private _symbol = 'FrogeX';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function manualswap() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function Opentrading() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 82,034 | 11,471 |
2ce7f5073ae32957f7dfaf26d4f4cad7f2775e58ce9f22cc233cb3a0a9434f58
| 22,601 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd1a7e773cbb9e4149a91ff860a871855bb109568.sol
| 4,970 | 18,547 |
pragma solidity ^0.4.24;
contract apexTWO {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
/// @dev notGasbag
modifier notGasbag() {
require(tx.gasprice < 200999999999);
_;
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
if (depositCount_ == 0){
require(ambassadors_[msg.sender] && msg.value == 0.001 ether);
}else
if (depositCount_ == 1 || depositCount_==2){
require(ambassadors_[msg.sender] && msg.value == 0.002 ether);
}
_;
}
/// @dev notGasbag
modifier isControlled() {
require(isPremine() || isStarted());
_;
}
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);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "apexTWO Token";
string public symbol = "APX2";
uint8 constant public decimals = 18;
/// @dev 12% dividends for token purchase
uint8 constant internal entryFee_ = 12;
/// @dev 48% dividends for token selling
uint8 constant internal startExitFee_ = 48;
/// @dev 12% dividends for token selling after step
uint8 constant internal finalExitFee_ = 12;
/// @dev Exit fee falls over period of 30 days
uint256 constant internal exitFeeFallDuration_ = 30 days;
/// @dev 12% masternode
uint8 constant internal refferalFee_ = 12;
/// @dev P3D pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 100 needed for masternode activation
uint256 public stakingRequirement = 100e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 0.1 ether;
uint256 public whaleBalanceLimit = 75 ether;
/// @dev apex starting gun
address public apex;
/// @dev starting
uint256 public startTime = 0; // January 1, 1970 12:00:00
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal bonusBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
constructor () public {
//Community Promotional Fund
ambassadors_[msg.sender]=true;
//1
ambassadors_[0x250F9cD6D75C8CDc34183a51b68ed727B86C1b41]=true;
//2
ambassadors_[0xb41342AE9432ee1DE63402766c6c0d9b460f7Eb4]=true;
apex = msg.sender;
}
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
require(msg.sender==apex && !isStarted() && now < _startTime);
startTime = _startTime;
}
function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , msg.sender);
}
function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , _customerAddress);
}
function() antiEarlyWhale notGasbag isControlled payable public {
purchaseTokens(msg.value, 0x0 , msg.sender);
}
/// @dev Converts all of caller's dividends to tokens.
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 , _customerAddress);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// capitulation
withdraw();
}
/// @dev Withdraws all of the callers earnings.
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
emit onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
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(SafeMath.mul(_ethereum, exitFee()), 100);
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
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
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) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
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;
}
}
/// @dev Return the buy price of 1 individual token.
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(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
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;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
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;
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(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 _ethereum;
}
/// @dev Function for getting the current exitFee
function exitFee() public view returns (uint8) {
if (startTime==0){
return startExitFee_;
}
if (now < startTime) {
return 0;
}
uint256 secondsPassed = now - startTime;
if (secondsPassed >= exitFeeFallDuration_) {
return finalExitFee_;
}
uint8 totalChange = startExitFee_ - finalExitFee_;
uint8 currentChange = uint8(totalChange * secondsPassed / exitFeeFallDuration_);
uint8 currentFee = startExitFee_- currentChange;
return currentFee;
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
return depositCount_<=7;
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
return startTime!=0 && now > startTime;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
// data setup
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// 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
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
// Keep track
depositCount_++;
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;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
| 199,734 | 11,472 |
39b90166cac130af9fa067908b1826cead1b8ac3bc54b712ae4f5ce06087d5b9
| 21,510 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TR82peVEpXzz2a8fCuHHmAQ2358GsGnhtJ_ecryptoSmart.sol
| 5,240 | 20,494 |
//SourceUnit: ecryptosmart.sol
pragma solidity 0.5.9;
contract ecryptoSmart {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 1;
address public doner;
address public deployer;
uint256 public contractDeployTime;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId, uint amount);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint amount);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address donerAddress) public {
levelPrice[1] = 600 * 1e6;
uint8 i;
for (i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
deployer = msg.sender;
doner = donerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[donerAddress] = user;
idToAddress[1] = donerAddress;
for (i = 1; i <= LAST_LEVEL; i++) {
users[donerAddress].activeX3Levels[i] = true;
users[donerAddress].activeX6Levels[i] = true;
}
userIds[1] = donerAddress;
contractDeployTime = now;
emit Registration(donerAddress, address(0), 1, 0, 0);
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, doner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable returns(string memory) {
registration(msg.sender, referrerAddress);
return "registration successful";
}
function registrationCreator(address userAddress, address referrerAddress) external returns(string memory) {
require(msg.sender==deployer, 'Invalid Donor');
require(contractDeployTime+86400 > now, 'This function is only available for first 24 hours');
registration(userAddress, referrerAddress);
return "registration successful";
}
function buyLevelCreator(address userAddress, uint8 matrix, uint8 level) external returns(string memory) {
require(msg.sender==deployer, 'Invalid Donor');
require(contractDeployTime+86400 > now, 'This function is only available for first 24 hours');
buyNewLevelInternal(userAddress, matrix, level);
return "Level bought successfully";
}
function buyNewLevel(uint8 matrix, uint8 level) external payable returns(string memory) {
buyNewLevelInternal(msg.sender, matrix, level);
return "Level bought successfully";
}
function buyNewLevelInternal(address user, uint8 matrix, uint8 level) private {
require(isUserExists(user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if(!(msg.sender==deployer)) require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[user].activeX3Levels[level], "level already activated");
if (users[user].x3Matrix[level-1].blocked) {
users[user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(user, level);
users[user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[user].activeX3Levels[level] = true;
updateX3Referrer(user, freeX3Referrer, level);
emit Upgrade(user, freeX3Referrer, 1, level, msg.value);
} else {
require(!users[user].activeX6Levels[level], "level already activated");
if (users[user].x6Matrix[level-1].blocked) {
users[user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(user, level);
users[user].activeX6Levels[level] = true;
updateX6Referrer(user, freeX6Referrer, level);
emit Upgrade(user, freeX6Referrer, 2, level, msg.value);
}
}
function registration(address userAddress, address referrerAddress) private {
if(!(msg.sender==deployer)) require(msg.value == (levelPrice[1]*2), "Invalid registration amount");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
lastUserId++;
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id, msg.value);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != doner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(doner, userAddress, 1, level);
users[doner].x3Matrix[level].reinvestCount++;
emit Reinvest(doner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == doner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != doner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(doner, address(0), userAddress, 2, level);
sendETHDividends(doner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender!=deployer)
{
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function viewLevels(address user) public view returns (bool[12] memory x3Levels, bool[12] memory x6Levels,uint8 x3LastTrue, uint8 x6LastTrue)
{
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
x3Levels[i] = users[user].activeX3Levels[i];
if(x3Levels[i]) x3LastTrue = i;
x6Levels[i] = users[user].activeX6Levels[i];
if(x6Levels[i]) x6LastTrue = i;
}
}
}
| 288,078 | 11,473 |
9af22274da865b5c1116ae94d896e030ffc8ce13ec3da3d2c63cbc8f9d8af3b6
| 26,829 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4595_18508_0x19e1d193a448bd13097efc2aea867468726e67c5.sol
| 5,042 | 23,202 |
pragma solidity 0.6.0;
contract Nest_3_TokenAbonus {
using address_make_payable for address;
using SafeMath for uint256;
ERC20 _nestContract;
Nest_3_TokenSave _tokenSave; // Lock-up contract
Nest_3_Abonus _abonusContract; // ETH bonus pool
Nest_3_VoteFactory _voteFactory; // Voting contract
Nest_3_Leveling _nestLeveling; // Leveling contract
address _destructionAddress; // Destroy contract address
uint256 _timeLimit = 168 hours; // Bonus period
uint256 _nextTime = 1596168000; // Next bonus time
uint256 _getAbonusTimeLimit = 60 hours; // During of triggering calculation of bonus
uint256 _times = 0; // Bonus ledger
uint256 _expectedIncrement = 3; // Expected bonus increment ratio
uint256 _expectedSpanForNest = 100000000 ether; // NEST expected bonus increment threshold
uint256 _expectedSpanForNToken = 1000000 ether; // NToken expected bonus increment threshold
uint256 _expectedMinimum = 100 ether; // Expected minimum bonus
uint256 _savingLevelOne = 10; // Saving threshold level 1
uint256 _savingLevelTwo = 20; // Saving threshold level 2
uint256 _savingLevelTwoSub = 100 ether; // Function parameters of savings threshold level 2
uint256 _savingLevelThree = 30; // Function parameters of savings threshold level 3
uint256 _savingLevelThreeSub = 600 ether; // Function parameters of savings threshold level 3
mapping(address => uint256) _abonusMapping; // Bonus pool snapshot - token address (NEST or NToken) => number of ETH in the bonus pool
mapping(address => uint256) _tokenAllValueMapping; // Number of tokens (circulation) - token address (NEST or NToken)) => total circulation
mapping(address => mapping(uint256 => uint256)) _tokenAllValueHistory;
mapping(address => mapping(uint256 => mapping(address => uint256))) _tokenSelfHistory;
mapping(address => mapping(uint256 => bool)) _snapshot;
mapping(uint256 => mapping(address => mapping(address => bool))) _getMapping; // Receiving records - period => token address (NEST or NToken) => user address => whether received
// Log token address, amount
event GetTokenLog(address tokenAddress, uint256 tokenAmount);
constructor (address voteFactory) public {
Nest_3_VoteFactory voteFactoryMap = Nest_3_VoteFactory(address(voteFactory));
_voteFactory = voteFactoryMap;
_nestContract = ERC20(address(voteFactoryMap.checkAddress("nest")));
_tokenSave = Nest_3_TokenSave(address(voteFactoryMap.checkAddress("nest.v3.tokenSave")));
address payable addr = address(voteFactoryMap.checkAddress("nest.v3.abonus")).make_payable();
_abonusContract = Nest_3_Abonus(addr);
address payable levelingAddr = address(voteFactoryMap.checkAddress("nest.v3.leveling")).make_payable();
_nestLeveling = Nest_3_Leveling(levelingAddr);
_destructionAddress = address(voteFactoryMap.checkAddress("nest.v3.destruction"));
}
function changeMapping(address voteFactory) public onlyOwner {
Nest_3_VoteFactory voteFactoryMap = Nest_3_VoteFactory(address(voteFactory));
_voteFactory = voteFactoryMap;
_nestContract = ERC20(address(voteFactoryMap.checkAddress("nest")));
_tokenSave = Nest_3_TokenSave(address(voteFactoryMap.checkAddress("nest.v3.tokenSave")));
address payable addr = address(voteFactoryMap.checkAddress("nest.v3.abonus")).make_payable();
_abonusContract = Nest_3_Abonus(addr);
address payable levelingAddr = address(voteFactoryMap.checkAddress("nest.v3.leveling")).make_payable();
_nestLeveling = Nest_3_Leveling(levelingAddr);
_destructionAddress = address(voteFactoryMap.checkAddress("nest.v3.destruction"));
}
function depositIn(uint256 amount, address token) public {
uint256 nowTime = now;
uint256 nextTime = _nextTime;
uint256 timeLimit = _timeLimit;
if (nowTime < nextTime) {
// Bonus triggered
require(!(nowTime >= nextTime.sub(timeLimit) && nowTime <= nextTime.sub(timeLimit).add(_getAbonusTimeLimit)));
} else {
// Bonus not triggered
uint256 times = (nowTime.sub(_nextTime)).div(_timeLimit);
// Calculate the time when bonus should be started
uint256 startTime = _nextTime.add((times).mul(_timeLimit));
// Calculate the time when bonus should be stopped
uint256 endTime = startTime.add(_getAbonusTimeLimit);
require(!(nowTime >= startTime && nowTime <= endTime));
}
_tokenSave.depositIn(amount, token, address(msg.sender));
}
function takeOut(uint256 amount, address token) public {
require(amount > 0, "Parameter needs to be greater than 0");
require(amount <= _tokenSave.checkAmount(address(msg.sender), token), "Insufficient storage balance");
if (token == address(_nestContract)) {
require(!_voteFactory.checkVoteNow(address(tx.origin)), "Voting");
}
_tokenSave.takeOut(amount, token, address(msg.sender));
}
function getAbonus(address token) public {
uint256 tokenAmount = _tokenSave.checkAmount(address(msg.sender), token);
require(tokenAmount > 0, "Insufficient storage balance");
reloadTime();
reloadToken(token);
uint256 nowTime = now;
require(nowTime >= _nextTime.sub(_timeLimit) && nowTime <= _nextTime.sub(_timeLimit).add(_getAbonusTimeLimit), "Not time to draw");
require(!_getMapping[_times.sub(1)][token][address(msg.sender)], "Have received");
_tokenSelfHistory[token][_times.sub(1)][address(msg.sender)] = tokenAmount;
require(_tokenAllValueMapping[token] > 0, "Total flux error");
uint256 selfNum = tokenAmount.mul(_abonusMapping[token]).div(_tokenAllValueMapping[token]);
require(selfNum > 0, "No limit available");
_getMapping[_times.sub(1)][token][address(msg.sender)] = true;
_abonusContract.getETH(selfNum, token,address(msg.sender));
emit GetTokenLog(token, selfNum);
}
function reloadTime() private {
uint256 nowTime = now;
// The current time must exceed the bonus time
if (nowTime >= _nextTime) {
uint256 time = (nowTime.sub(_nextTime)).div(_timeLimit);
uint256 startTime = _nextTime.add((time).mul(_timeLimit));
uint256 endTime = startTime.add(_getAbonusTimeLimit);
if (nowTime >= startTime && nowTime <= endTime) {
_nextTime = getNextTime();
_times = _times.add(1);
}
}
}
function reloadToken(address token) private {
if (!_snapshot[token][_times.sub(1)]) {
levelingResult(token);
_abonusMapping[token] = _abonusContract.getETHNum(token);
_tokenAllValueMapping[token] = allValue(token);
_tokenAllValueHistory[token][_times.sub(1)] = allValue(token);
_snapshot[token][_times.sub(1)] = true;
}
}
function levelingResult(address token) private {
uint256 steps;
if (token == address(_nestContract)) {
steps = allValue(token).div(_expectedSpanForNest);
} else {
steps = allValue(token).div(_expectedSpanForNToken);
}
uint256 minimumAbonus = _expectedMinimum;
for (uint256 i = 0; i < steps; i++) {
minimumAbonus = minimumAbonus.add(minimumAbonus.mul(_expectedIncrement).div(100));
}
uint256 thisAbonus = _abonusContract.getETHNum(token);
if (thisAbonus > minimumAbonus) {
uint256 levelAmount = 0;
if (thisAbonus > 5000 ether) {
levelAmount = thisAbonus.mul(_savingLevelThree).div(100).sub(_savingLevelThreeSub);
} else if (thisAbonus > 1000 ether) {
levelAmount = thisAbonus.mul(_savingLevelTwo).div(100).sub(_savingLevelTwoSub);
} else {
levelAmount = thisAbonus.mul(_savingLevelOne).div(100);
}
if (thisAbonus.sub(levelAmount) < minimumAbonus) {
_abonusContract.getETH(thisAbonus.sub(minimumAbonus), token, address(this));
_nestLeveling.switchToEth.value(thisAbonus.sub(minimumAbonus))(token);
} else {
_abonusContract.getETH(levelAmount, token, address(this));
_nestLeveling.switchToEth.value(levelAmount)(token);
}
} else {
uint256 ethValue = _nestLeveling.tranEth(minimumAbonus.sub(thisAbonus), token, address(this));
_abonusContract.switchToEth.value(ethValue)(token);
}
}
function getInfo(address token) public view returns (uint256 nextTime, uint256 getAbonusTime, uint256 ethNum, uint256 tokenValue, uint256 myJoinToken, uint256 getEth, uint256 allowNum, uint256 leftNum, bool allowAbonus) {
uint256 nowTime = now;
if (nowTime >= _nextTime.sub(_timeLimit) && nowTime <= _nextTime.sub(_timeLimit).add(_getAbonusTimeLimit) && _times > 0 && _snapshot[token][_times.sub(1)]) {
// Bonus have been triggered, and during the time of this bonus, display snapshot data
allowAbonus = _getMapping[_times.sub(1)][token][address(msg.sender)];
ethNum = _abonusMapping[token];
tokenValue = _tokenAllValueMapping[token];
} else {
// Display real-time data
ethNum = _abonusContract.getETHNum(token);
tokenValue = allValue(token);
allowAbonus = _getMapping[_times][token][address(msg.sender)];
}
myJoinToken = _tokenSave.checkAmount(address(msg.sender), token);
if (allowAbonus == true) {
getEth = 0;
} else {
getEth = myJoinToken.mul(ethNum).div(tokenValue);
}
nextTime = getNextTime();
getAbonusTime = nextTime.sub(_timeLimit).add(_getAbonusTimeLimit);
allowNum = ERC20(token).allowance(address(msg.sender), address(_tokenSave));
leftNum = ERC20(token).balanceOf(address(msg.sender));
}
function getNextTime() public view returns (uint256) {
uint256 nowTime = now;
if (_nextTime > nowTime) {
return _nextTime;
} else {
uint256 time = (nowTime.sub(_nextTime)).div(_timeLimit);
return _nextTime.add(_timeLimit.mul(time.add(1)));
}
}
function allValue(address token) public view returns (uint256) {
if (token == address(_nestContract)) {
uint256 all = 10000000000 ether;
uint256 leftNum = all.sub(_nestContract.balanceOf(address(_voteFactory.checkAddress("nest.v3.miningSave")))).sub(_nestContract.balanceOf(address(_destructionAddress)));
return leftNum;
} else {
return ERC20(token).totalSupply();
}
}
function checkTimeLimit() public view returns (uint256) {
return _timeLimit;
}
function checkGetAbonusTimeLimit() public view returns (uint256) {
return _getAbonusTimeLimit;
}
function checkMinimumAbonus(address token) public view returns (uint256) {
uint256 miningAmount;
if (token == address(_nestContract)) {
miningAmount = allValue(token).div(_expectedSpanForNest);
} else {
miningAmount = allValue(token).div(_expectedSpanForNToken);
}
uint256 minimumAbonus = _expectedMinimum;
for (uint256 i = 0; i < miningAmount; i++) {
minimumAbonus = minimumAbonus.add(minimumAbonus.mul(_expectedIncrement).div(100));
}
return minimumAbonus;
}
function checkSnapshot(address token) public view returns (bool) {
return _snapshot[token][_times.sub(1)];
}
function checkeExpectedIncrement() public view returns (uint256) {
return _expectedIncrement;
}
function checkExpectedMinimum() public view returns (uint256) {
return _expectedMinimum;
}
function checkSavingLevelOne() public view returns (uint256) {
return _savingLevelOne;
}
function checkSavingLevelTwo() public view returns (uint256) {
return _savingLevelTwo;
}
function checkSavingLevelThree() public view returns (uint256) {
return _savingLevelThree;
}
function checkTokenAllValueHistory(address token, uint256 times) public view returns (uint256) {
return _tokenAllValueHistory[token][times];
}
function checkTokenSelfHistory(address token, uint256 times, address user) public view returns (uint256) {
return _tokenSelfHistory[token][times][user];
}
// View the period number of bonus
function checkTimes() public view returns (uint256) {
return _times;
}
// NEST expected bonus increment threshold
function checkExpectedSpanForNest() public view returns (uint256) {
return _expectedSpanForNest;
}
// NToken expected bonus increment threshold
function checkExpectedSpanForNToken() public view returns (uint256) {
return _expectedSpanForNToken;
}
// View the function parameters of savings threshold level 3
function checkSavingLevelTwoSub() public view returns (uint256) {
return _savingLevelTwoSub;
}
// View the function parameters of savings threshold level 3
function checkSavingLevelThreeSub() public view returns (uint256) {
return _savingLevelThreeSub;
}
function changeTimeLimit(uint256 hour) public onlyOwner {
require(hour > 0, "Parameter needs to be greater than 0");
_timeLimit = hour.mul(1 hours);
}
function changeGetAbonusTimeLimit(uint256 hour) public onlyOwner {
require(hour > 0, "Parameter needs to be greater than 0");
_getAbonusTimeLimit = hour;
}
function changeExpectedIncrement(uint256 num) public onlyOwner {
require(num > 0, "Parameter needs to be greater than 0");
_expectedIncrement = num;
}
function changeExpectedMinimum(uint256 num) public onlyOwner {
require(num > 0, "Parameter needs to be greater than 0");
_expectedMinimum = num;
}
function changeSavingLevelOne(uint256 threshold) public onlyOwner {
_savingLevelOne = threshold;
}
function changeSavingLevelTwo(uint256 threshold) public onlyOwner {
_savingLevelTwo = threshold;
}
function changeSavingLevelThree(uint256 threshold) public onlyOwner {
_savingLevelThree = threshold;
}
function changeSavingLevelTwoSub(uint256 num) public onlyOwner {
_savingLevelTwoSub = num;
}
function changeSavingLevelThreeSub(uint256 num) public onlyOwner {
_savingLevelThreeSub = num;
}
function changeExpectedSpanForNest(uint256 num) public onlyOwner {
_expectedSpanForNest = num;
}
function changeExpectedSpanForNToken(uint256 num) public onlyOwner {
_expectedSpanForNToken = num;
}
receive() external payable {
}
// Administrator only
modifier onlyOwner(){
require(_voteFactory.checkOwners(address(msg.sender)), "No authority");
_;
}
}
// NEST and NToken lock-up contracts
interface Nest_3_TokenSave {
function depositIn(uint256 num, address token, address target) external;
function checkAmount(address sender, address token) external view returns(uint256);
function takeOut(uint256 num, address token, address target) external;
}
// ETH bonus pool
interface Nest_3_Abonus {
function getETH(uint256 num, address token, address target) external;
function getETHNum(address token) external view returns (uint256);
function switchToEth(address token) external payable;
}
// Leveling contract
interface Nest_3_Leveling {
function tranEth(uint256 amount, address token, address target) external returns (uint256);
function switchToEth(address token) external payable;
}
// Voting factory contract
interface Nest_3_VoteFactory {
// Check if there is a vote currently participating
function checkVoteNow(address user) external view returns(bool);
// Check address
function checkAddress(string calldata name) external view returns (address contractAddress);
// Check whether the administrator
function checkOwners(address man) external view returns (bool);
}
// ERC20 contract
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library address_make_payable {
function make_payable(address x) internal pure returns (address payable) {
return address(uint160(x));
}
}
| 230,198 | 11,474 |
815f90ba3191c2287b7b0c8bbf03db121a0c55862a51254726670464adb0156c
| 12,887 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUKPRnFMq4WoDQ1PFVC2QKDEVxwr3KCrjM_LEX.sol
| 3,858 | 12,400 |
//SourceUnit: LEX.sol
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract TRC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract LEX is TRC20Interface {
using SafeMath for uint256;
string public constant NAME = "LightExchangeToken";
string public constant SYMBOL = "LEX";
uint256 public decimals = 6;
uint256 public maximumTokens = 1e14; //100M TOKENS
uint256 private constant preSellPrice = 10; //1 TOKEN = 10 TRX
uint256 private constant preSellTime1 = 1575903600; //50% discont from 12/09/2019 @ 3:00pm (UTC)
uint256 private constant preSellTime2 = 1578582000; //37% discont from 01/09/2020 @ 3:00pm (UTC)
uint256 private constant preSellTime3 = 1581260400; //16% discont from 02/09/2020 @ 3:00pm (UTC)
uint256 private constant preSellLimit1 = 22e11; //2.2M TOKENS
uint256 private constant preSellLimit2 = 16e11; //1.6M TOKENS
uint256 private constant preSellLimit3 = 12e11; //1.2M TOKENS
uint256 public totalPreSelled;
//dividends
uint256 private dividendsPerToken;
uint256 private totalDividendsPayed;
uint256 public totalDividends;
//frozen dividends
uint256 public totalFrozenTokens;
uint256 private unfreezeDate = 1584630000; //03/19/2020 @ 3:00pm (UTC)
uint256 gamesCount;
mapping (uint256 => address) private games;
mapping (address => uint256) public dividendStat;
mapping (address => uint256) private heldDividends;
mapping (address => uint256) public frozenTokens;
mapping (address => uint256) private dividendsToPay;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
address public contractOwner;
address public marketing;
address public developing;
event ContractOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _marketing, address _developing) public {
contractOwner = msg.sender;
marketing = _marketing;
developing = _developing;
_mint(contractOwner, 3e12);
frozenTokens[contractOwner] = 3e12;
_mint(marketing, 3e12);
frozenTokens[marketing] = 3e12;
_mint(developing, 4e12);
frozenTokens[developing] = 4e12;
totalFrozenTokens = totalFrozenTokens.add(10e12);
}
modifier onlyContractOwner() {
require(msg.sender == contractOwner);
_;
}
function transferContractOwnership(address _newOwner) public onlyContractOwner {
require(_newOwner != address(0));
emit ContractOwnershipTransferred(contractOwner, _newOwner);
contractOwner = _newOwner;
}
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(msg.sender, recipient, amount);
return true;
}
function allowance(address admin, address spender) public view returns (uint256) {
return _allowances[admin][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
updateDividends(sender);
updateDividends(recipient);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
if (frozenTokens[sender] >= amount) {
frozenTokens[sender] = frozenTokens[sender].sub(amount);
totalFrozenTokens = totalFrozenTokens.sub(amount);
} else if (frozenTokens[sender] > 0) {
totalFrozenTokens = totalFrozenTokens.sub(frozenTokens[sender]);
frozenTokens[sender] = 0;
}
if (now < unfreezeDate) {
frozenTokens[recipient] = frozenTokens[recipient].add(amount);
totalFrozenTokens = totalFrozenTokens.add(amount);
}
holdDividends(sender);
holdDividends(recipient);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "TRC20: 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 value) internal {
require(account != address(0), "TRC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address admin, address spender, uint256 value) internal {
require(admin != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[admin][spender] = value;
emit Approval(admin, spender, value);
}
function name() public pure returns(string) {
return NAME;
}
function symbol() public pure returns(string) {
return SYMBOL;
}
//end TRC20 functions
function() public payable {
preSell();
}
function preSell() public payable {
uint256 tokensToBuyValue;
if (now < preSellTime1) {
revert("Too early...");
} else if (now >= preSellTime1 && now< preSellTime2) {
//50% discont
require (totalPreSelled < preSellLimit1, "Pre-sell one is finished, wait for pre-sell two.");
tokensToBuyValue = msg.value.mul(100).div(50).div(preSellPrice);
require (totalPreSelled + tokensToBuyValue <= preSellLimit1, "Pre-sell limit exceeded");
} else if (now >= preSellTime2 && now< preSellTime3) {
//37% discont
require (totalPreSelled < preSellLimit1 + preSellLimit2, "Pre-sell two is finished, wait for pre-sell three.");
tokensToBuyValue = msg.value.mul(100).div(63).div(preSellPrice);
require (totalPreSelled + tokensToBuyValue <= preSellLimit1 + preSellLimit2, "Pre-sell limit exceeded");
} else {
//16% discont
require (totalPreSelled < preSellLimit1 + preSellLimit2 + preSellLimit3, "Pre-sell is finished");
tokensToBuyValue = msg.value.mul(100).div(84).div(preSellPrice);
require (totalPreSelled + tokensToBuyValue <= preSellLimit1 + preSellLimit2 + preSellLimit3, "Pre-sell limit exceeded");
}
if (tokensToBuyValue > 0) {
updateDividends(msg.sender);
_mint(msg.sender, tokensToBuyValue);
totalPreSelled = totalPreSelled.add(tokensToBuyValue);
if (now < unfreezeDate) {
frozenTokens[msg.sender] = frozenTokens[msg.sender].add(tokensToBuyValue);
totalFrozenTokens = totalFrozenTokens.add(tokensToBuyValue);
}
holdDividends(msg.sender);
}
}
function WithdrawPreSell(uint256 _value, bool _safeDivs) external onlyContractOwner {
uint256 toPayValue = _value;
if (_safeDivs) {
uint256 maxValue = address(this).balance.add(totalDividendsPayed).sub(totalDividends);
if (toPayValue > maxValue) {
toPayValue = maxValue;
}
}
contractOwner.transfer(toPayValue.mul(333).div(1000));
marketing.transfer(toPayValue.mul(333).div(1000));
developing.transfer(toPayValue.mul(333).div(1000));
}
function burnTokens(uint256 _value) external {
require (_value>0 && _value<=_balances[msg.sender],"Wrong burn value");
updateDividends(msg.sender);
if (frozenTokens[msg.sender] >= _value) {
frozenTokens[msg.sender] = frozenTokens[msg.sender].sub(_value);
totalFrozenTokens = totalFrozenTokens.sub(_value);
} else if (frozenTokens[msg.sender] > 0) {
totalFrozenTokens = totalFrozenTokens.sub(frozenTokens[msg.sender]);
frozenTokens[msg.sender] = 0;
}
_burn(msg.sender, _value);
holdDividends(msg.sender);
}
function emission(address account, uint256 trxValue) external {
require (isGame(msg.sender), "Access denied");
uint256 subNum = _totalSupply;
if (subNum < maximumTokens.mul(15).div(100)) {
subNum = maximumTokens.mul(15).div(100);
}
uint256 minedTokens = trxValue.div(765).mul(maximumTokens.sub(subNum)).div(maximumTokens);
if (minedTokens > 0) {
updateDividends(account);
_mint(account, minedTokens);
holdDividends(account);
}
}
function riseDividends() external payable {
dividendsPerToken = dividendsPerToken.add(msg.value.mul(1e6).div(_totalSupply.sub(totalFrozenTokens)));
totalDividends = totalDividends.add(msg.value);
}
function getDividends() public {
updateDividends(msg.sender);
if (dividendsToPay[msg.sender]>0) {
msg.sender.transfer(dividendsToPay[msg.sender]);
totalDividendsPayed = totalDividendsPayed.add(dividendsToPay[msg.sender]);
dividendStat[msg.sender] = totalDividendsPayed.add(dividendsToPay[msg.sender]);
dividendsToPay[msg.sender] = 0;
}
}
function unfreezeTokens() external {
require (msg.sender != contractOwner && msg.sender != marketing && msg.sender != developing, "It isn't for admins");
require (now >= unfreezeDate, "It isn't time for unfreeze");
updateDividends(msg.sender);
totalFrozenTokens = totalFrozenTokens.sub(frozenTokens[msg.sender]);
frozenTokens[msg.sender] = 0;
holdDividends(msg.sender);
}
function addGame(address game) external onlyContractOwner {
games[gamesCount] = game;
gamesCount++;
}
function holdDividends(address account) private {
heldDividends[account] = _balances[account].sub(frozenTokens[account]).mul(dividendsPerToken).div(1e6);
}
function updateDividends(address account) private {
uint256 divs = getDividendsValue(account);
dividendsToPay[account] = dividendsToPay[account].add(divs);
holdDividends(account);
}
function getDividendsValue(address account) private view returns(uint256) {
uint256 divs = _balances[account].sub(frozenTokens[account]).mul(dividendsPerToken).div(1e6);
if (divs > heldDividends[account]) {
return divs.sub(heldDividends[account]);
}
return 0;
}
function getDividendsToPay(address account) public view returns(uint256) {
return getDividendsValue(account) + dividendsToPay[account];
}
function isGame(address game) private view returns(bool){
for (uint256 i=0; i<gamesCount; i++) {
if (games[i] == game) {
return true;
}
}
return false;
}
}
| 303,121 | 11,475 |
5afb9856ab3b9e058f12333c8ee4dbd01a1c856924c064c1ccc97cf926c291cc
| 15,674 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEhDA4TmJ54gyqdgVGVKFgkAMH7S3UyreB_AtomToken.sol
| 4,190 | 14,825 |
//SourceUnit: AtomToken-Invest.sol
pragma solidity 0.5.10;
contract AtomToken {
using SafeMath for uint256;
uint256 constant public MIN_INVEST_AMOUNT = 50 trx;
uint256 constant public MIN_WITHDRAW = 5 trx;
uint256 constant public MAX_WITHDRAW = 30000 trx;
uint256 constant public MAX_INVEST_AMOUNT = 100000 trx;
uint256 constant public INVEST_BASE_PERCENT = 300; //3%
uint256[] public REFERRAL_PERCENTS = [500, 400, 300 , 200, 100]; // 5% 4% 3% 2% 1%
uint256 constant public MULTIPLIER = 25;
uint256 constant public DAILY_MULTIPLIER = 20;
uint256 constant public TOTAL_PROFIT = 250; //250%
uint256 constant public LOCKDOWN_POOL_MIN_AMOUNT_PERCENT = 35; //35%
uint256 constant public DIVIDER = 100;
uint256 constant public MULTIPLIER_DIVIDER = 10;
uint256 constant public PERCENTS_DIVIDER = 10000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public COMMISION_FEE_PERCENT = 1000; // 10%
uint256 public totalInvestments;
uint256 public totalInvested;
uint256 public totalWithdrawn;
address payable public projectAddress;
//Construct Invest Arguments
struct Investment {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct Investor {
Investment[] invests;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 caninvest;
uint256 canreinvest;
uint256 unusable_bonus;
uint256 refs1;
uint256 refs2;
uint256 refs3;
uint256 refs4;
uint256 refs5;
}
mapping (address => Investor) internal users;
event Newbie(address user);
event NewInvestment(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event FeePayment(uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable projectAddr) public {
require(!isContract(projectAddr));
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
Investor storage user = users[msg.sender];
if (user.invests.length == 0) {
user.caninvest = 1;
}
uint256 stateinvest = user.caninvest;
require(stateinvest > 0 , "You Cant Invest!");
require(msg.value >= MIN_INVEST_AMOUNT, "Minimum invest is 50 TRX");
require(msg.value < MAX_INVEST_AMOUNT, "Maximum 100,000 TRX deposit per address");
uint256 fee = msg.value.mul(COMMISION_FEE_PERCENT).div(PERCENTS_DIVIDER);
projectAddress.transfer(fee);
emit FeePayment(fee);
uint256 realamount = msg.value.sub(fee);
if (user.referrer == address(0) && users[referrer].invests.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = realamount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if (i == 0) {
users[upline].refs1 = users[upline].refs1.add(amount);
}
if (i == 1) {
users[upline].refs2 = users[upline].refs2.add(amount);
}
if (i == 2) {
users[upline].refs3 = users[upline].refs3.add(amount);
}
if (i == 3) {
users[upline].refs4 = users[upline].refs4.add(amount);
}
if (i == 4) {
users[upline].refs5 = users[upline].refs5.add(amount);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.invests.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
user.invests.push(Investment(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalInvestments = totalInvestments.add(1);
user.caninvest = 0;
if (msg.value > MAX_INVEST_AMOUNT) {
user.canreinvest = 0;
}
user.canreinvest = 1;
emit NewInvestment(msg.sender, msg.value);
}
function reinvest(address referrer) public payable {
Investor storage user = users[msg.sender];
uint256 stateinvest = user.caninvest;
uint256 statereinvest = user.canreinvest;
require (stateinvest != 1 , "You Dont Invested");
require (statereinvest != 0 , "You Cant reinvest") ;
uint256 userInvested;
for (uint256 i = 0; i < user.invests.length; i++) {
userInvested = userInvested.add(user.invests[i].amount);
}
uint256 inv = msg.value;
require(inv.sub(userInvested) < MAX_INVEST_AMOUNT, "Your Invest Should be Maximum 100,000 TRX");
uint256 fee = msg.value.mul(COMMISION_FEE_PERCENT).div(PERCENTS_DIVIDER);
projectAddress.transfer(fee);
emit FeePayment(fee);
uint256 realamount = msg.value.sub(fee);
if (user.referrer == address(0) && users[referrer].invests.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = realamount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if (i == 0) {
users[upline].refs1 = users[upline].refs1.add(amount);
}
if (i == 1) {
users[upline].refs2 = users[upline].refs2.add(amount);
}
if (i == 2) {
users[upline].refs3 = users[upline].refs3.add(amount);
}
if (i == 3) {
users[upline].refs4 = users[upline].refs4.add(amount);
}
if (i == 4) {
users[upline].refs5 = users[upline].refs5.add(amount);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.invests.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
user.invests.push(Investment(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalInvestments = totalInvestments.add(1);
emit NewInvestment(msg.sender, msg.value);
}
function withdraw() public {
Investor storage user = users[msg.sender];
uint256 userPercentRate = getInvestorPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
if (msg.sender == projectAddress) {
uint projectFee = address(this).balance;
projectAddress.transfer(projectFee);
}
for (uint256 i = 0; i < user.invests.length; i++) {
if (user.invests[i].withdrawn < user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)) {
if (user.invests[i].start > user.checkpoint) {
dividends = (user.invests[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.invests[i].start))
.div(TIME_STEP);
} else {
dividends = (user.invests[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.invests[i].withdrawn.add(dividends) > user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)) {
dividends = (user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)).sub(user.invests[i].withdrawn);
user.caninvest = 1;
user.canreinvest = 0;
}
user.invests[i].withdrawn = user.invests[i].withdrawn.add(dividends);
totalAmount = totalAmount.add(dividends);
}
}
if (user.bonus > 0) {
totalAmount = totalAmount.add(user.bonus);
user.bonus = 0;
}
require(totalAmount > MIN_WITHDRAW, "Minimum withdraw is 5 TRX");
require(totalAmount < MAX_WITHDRAW, "Maximum 30,000 TRX Withdraw Limit per address");
uint256 LockdownAmount = getContractLockdownBalance();
uint256 TotalInv = totalInvested;
if (userPercentRate > 1700) {
require (LockdownAmount <= TotalInv, "You Cant Withdraw Because You Are Exeeded 170% Divide");
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractLockdownBalance() public view returns (uint256) {
uint256 totalbalance = getContractBalance();
return totalbalance.mul(LOCKDOWN_POOL_MIN_AMOUNT_PERCENT).div(DIVIDER);
}
function getInvestorPercentRate(address userAddress) public view returns (uint256) {
Investor storage user = users[userAddress];
uint256 contractBalanceRate = INVEST_BASE_PERCENT;
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier.mul(DAILY_MULTIPLIER));
} else {
return contractBalanceRate;
}
}
function isActive(address userAddress) public view returns (bool) {
Investor storage user = users[userAddress];
return (user.invests.length > 0) && user.invests[user.invests.length-1].withdrawn < user.invests[user.invests.length-1].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER);
}
function isContract(address userAddress) internal view returns (bool) {
uint size;
assembly { size := extcodesize(userAddress) }
return size > 0;
}
function getMainStats() public view returns (uint256, uint256, uint256, uint256) {
return (totalInvested, totalWithdrawn, totalInvestments, getContractBalance());
}
function getInvestorStats(address userAddress) public view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
Investor storage user = users[userAddress];
uint256 userPercentRate = getInvestorPercentRate(userAddress);
uint256 userAvailable = user.bonus;
uint256 dividends;
for (uint256 i = 0; i < user.invests.length; i++) {
if (user.invests[i].withdrawn < user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)) {
if (user.invests[i].start > user.checkpoint) {
dividends = (user.invests[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.invests[i].start))
.div(TIME_STEP);
} else {
dividends = (user.invests[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.invests[i].withdrawn.add(dividends) > user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)) {
dividends = (user.invests[i].amount.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER)).sub(user.invests[i].withdrawn);
}
userAvailable = userAvailable.add(dividends);
}
}
uint256 userInvested;
for (uint256 i = 0; i < user.invests.length; i++) {
userInvested = userInvested.add(user.invests[i].amount);
}
uint256 userInvestments = user.invests.length;
uint256 userLastInvestmentDate;
if (userInvestments > 0) {
userLastInvestmentDate = user.invests[userInvestments-1].start;
}
uint256 userWithdrawn;
for (uint256 i = 0; i < user.invests.length; i++) {
userWithdrawn = userWithdrawn.add(user.invests[i].withdrawn);
}
userWithdrawn = userWithdrawn.add(user.refs1).add(user.refs2).add(user.refs3).sub(user.bonus);
return (userPercentRate, userAvailable, userInvested, userInvestments, userLastInvestmentDate, userWithdrawn);
}
function TotalUserCanGet(address userAddress) public view returns (uint256) {
Investor storage user = users[userAddress];
uint256 userInvested;
for (uint256 i = 0; i < user.invests.length; i++) {
userInvested = userInvested.add(user.invests[i].amount);
}
uint256 total = userInvested.mul(MULTIPLIER).div(MULTIPLIER_DIVIDER);
return total;
}
function getInvestorRefInfo(address userAddress) public view returns (address, uint256, uint256, uint256 , uint256 , uint256) {
Investor storage user = users[userAddress];
return (user.referrer, user.refs1, user.refs2, user.refs3 , user.refs4 , user.refs5);
}
function abs(uint256 x) private pure returns (uint256) {
return x >= 0 ? x : -x;
}
}
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 abs(uint256 x) internal pure returns (uint256) {
return x >= 0 ? x : -x;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 292,050 | 11,476 |
0301d0091099b38c50b45551b5d76801fe669623d702d49e258f533068117b6b
| 18,119 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4d/4d6f02a20e98bd507d5f0a235076cf52cb7f726f_Distributor.sol
| 3,987 | 15,737 |
// 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 PiggyBank;
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 _PiggyBank, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_PiggyBank != address(0));
PiggyBank = _PiggyBank;
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(PiggyBank).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 75,854 | 11,477 |
247373a1f611d0f80625458fb36199289154627e4444f7d42e0ede14c2a14590
| 29,655 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/39/39c54076a590B4dE1Ec244388342FD8bA4039cC6_SexOrgasmToken.sol
| 5,203 | 18,745 |
// 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 SexOrgasmToken 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 = 50000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Sex Orgasm Token';
string private constant _symbol = 'SOT';
uint256 private _taxFee = 100;
uint256 private _burnFee = 0;
uint public max_tx_size = 50000000 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 != 0xf575aE1006D07785Bd43d8C66244f3F7DC811321, '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,365 | 11,478 |
808dd5b58437366abd11cac231b700919aeeef322be45c1039ce23ae6f96d6dd
| 26,906 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/28/28043677275c91d4bb581d955dfa7121fe59b75b_TheArena.sol
| 5,387 | 19,968 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
'Ownable: new owner is the zero address');
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract TheArena is Context, Ownable {
address rndm = 0x87d57F92852D7357Cf32Ac4F6952204f2B0c1A27;
IERC20 rndmToken = IERC20(rndm);
event WithdrewBalance(address indexed player, uint256 eth);
event BoughtCombatant(address indexed player,
uint256 eth,
uint256 combatant);
event SkippedAhead(address indexed player, uint256 eth, uint256 combatant);
event TradedVictory(address indexed player, uint256 eth, uint256 victory);
event BecameChampion(address indexed player, uint256 eth);
event AssassinatedChampion(address indexed player, uint256 eth);
event SacrificedCombatant(address indexed player);
event SteppedDown(address indexed player, uint256 eth);
event TimeWarped(address indexed player, uint256 indexed loop, uint256 eth);
event NewLoop(address indexed player, uint256 indexed loop);
event BoostedPot(address indexed player, uint256 eth);
uint256 public ARENA_TIMER_START = 604800; //7 days
uint256 public TOTALCHAOS_LENGTH = 3600; //1 hour
uint256 public SACRIFICE_COMBATANT_REQ = 200; //combatants to become champion
uint256 public CHAMPION_TIMER_BOOST = 360; //6 minutes
uint256 public COMBATANT_COST_FLOOR = 1000000000000000000; //100x ETH cost to account for 1 ETH ~= 130 DAI |||||| This is 1 token
uint256 public DIV_COMBATANT_COST = 10000; //loop pot divider
uint256 public TOKEN_MAX_BUY = 400000000000000000000; //max allowed FTM in one buy transaction |||||||| This is 400 token
uint256 public MIN_VICTORY = 100;
uint256 public MAX_VICTORY = 1000;
uint256 public ACCEL_FACTOR = 672; //inverse of acceleration per second
uint256 public MILE_REQ = 6000; //required victories for 1% of the pot
// Race starter
address public starter;
bool public gameStarted;
// loop, timer, champion
uint256 public loop;
uint256 public timer;
address public champion;
// Are we in totalChaos?
bool public totalChaos = false;
// Last champion claim
uint256 public lastAssassination;
// Pots
uint256 public loopChest;
uint256 public combatantBank;
// Divs for one combatant, max amount of combatants
uint256 public divPerCombatant;
uint256 public maxCombatant;
mapping(address => uint256) public combatantCamp;
mapping(address => uint256) public playerBalance;
mapping(address => uint256) public claimedDiv;
mapping(address => uint256) public victory;
//-- GAME START --
// Constructor
constructor() {
gameStarted = false;
}
// StartGame
// Initialize timer
// Set starter (owner of the contract) as champion (starter can't win or trade victories)
// Buy tokens for value of message
function StartGame(uint256 _rndmAmount) public onlyOwner {
require(gameStarted == false);
starter = msg.sender;
timer = block.timestamp + (ARENA_TIMER_START) + (TOTALCHAOS_LENGTH);
loop = 1;
gameStarted = true;
lastAssassination = block.timestamp;
champion = starter;
BuyCombatant(_rndmAmount);
}
//-- PRIVATE --
// PotSplit
// Called on buy and hatch
// 40% divs, 40% combatantBank, 20% loopChest
function PotSplit(uint256 _msgValue) private {
divPerCombatant =
divPerCombatant +
((_msgValue * (2)) / (5) / (maxCombatant));
combatantBank = combatantBank + ((_msgValue * (2)) / (5));
loopChest = loopChest + (_msgValue / (5));
}
// ClaimDiv
// Sends player dividends to his playerBalance
// Adjusts claimable dividends
function ClaimDiv() private {
uint256 _playerDiv = ComputeDiv(msg.sender);
if (_playerDiv > 0) {
//Add new divs to claimed divs
claimedDiv[msg.sender] = claimedDiv[msg.sender] + (_playerDiv);
//Send divs to playerBalance
playerBalance[msg.sender] =
playerBalance[msg.sender] +
(_playerDiv);
}
}
// BecomeChampion
// Gives champion role, and victories to previous champion
function BecomeChampion() private {
//give victories to previous champion
uint256 _victory = ComputeVictoryWon();
victory[champion] = victory[champion] + (_victory);
//if we're in totalChaos, the new champion ends up 6 minutes before totalChaos
if (block.timestamp + (TOTALCHAOS_LENGTH) >= timer) {
timer =
block.timestamp +
(CHAMPION_TIMER_BOOST) +
(TOTALCHAOS_LENGTH);
emit AssassinatedChampion(msg.sender, loopChest);
//else, simply add 6 minutes to timer
} else {
timer = timer + (CHAMPION_TIMER_BOOST);
emit BecameChampion(msg.sender, loopChest);
}
lastAssassination = block.timestamp;
champion = msg.sender;
}
//-- ACTIONS --
// TimeWarp
// Call manually when race is over
// Distributes loopchest and victories to winner, moves to next loop
function TimeWarp() public {
require(gameStarted == true, "game hasn't started yet");
require(block.timestamp >= timer, "arena isn't finished yet");
//give victories to champion
uint256 _victory = ComputeVictoryWon();
victory[champion] = victory[champion] + (_victory);
//Reset timer and start new loop
timer = block.timestamp + (ARENA_TIMER_START) + (TOTALCHAOS_LENGTH);
loop++;
//Adjust loop and combatant pots
uint256 _nextPot = combatantBank / (2);
combatantBank = combatantBank - (_nextPot);
//Make sure the car isn't driving freely
if (champion != starter) {
//Calculate reward
uint256 _reward = loopChest;
//Change loopchest
loopChest = _nextPot;
//Give reward
playerBalance[champion] = playerBalance[champion] + (_reward);
emit TimeWarped(champion, loop, _reward);
//Else, start a new loop with different event
} else {
//Change loopchest
loopChest = loopChest + (_nextPot);
emit NewLoop(msg.sender, loop);
}
lastAssassination = block.timestamp;
//msg.sender becomes Champion
champion = msg.sender;
}
// BuyCombatant
// Get token price, adjust maxCombatant and divs, give combatants
function BuyCombatant(uint256 _rndmAmount) public {
require(gameStarted == true, "game hasn't started yet");
require(tx.origin == msg.sender, 'contracts not allowed');
require(_rndmAmount <= TOKEN_MAX_BUY, 'maximum buy = 40 FTM');
require(block.timestamp <= timer, 'race is over!');
rndmToken.transferFrom(msg.sender, address(this), _rndmAmount);
//Calculate price and resulting combatants
uint256 fee = _rndmAmount * 5 / 100;
_rndmAmount -= fee;
rndmToken.transfer(owner(), fee);
uint256 _combatantBought = ComputeBuy(_rndmAmount, true);
//Adjust player claimed divs
claimedDiv[msg.sender] =
claimedDiv[msg.sender] +
(_combatantBought * (divPerCombatant));
//Change maxCombatant before new div calculation
maxCombatant = maxCombatant + (_combatantBought);
//Divide incoming RNDM
PotSplit(_rndmAmount);
//Add player combatants
combatantCamp[msg.sender] =
combatantCamp[msg.sender] +
(_combatantBought);
emit BoughtCombatant(msg.sender, _rndmAmount+fee, _combatantBought);
//Become champion if player bought at least 200 combatants
if (_combatantBought >= 200) {
BecomeChampion();
}
}
// SkipAhead
// Functions like BuyCombatant, using player balance
// Less cost per Combatant (+1 loop)
function SkipAhead() public {
require(gameStarted == true, "game hasn't started yet");
ClaimDiv();
require(playerBalance[msg.sender] > 0, 'no ether to timetravel');
require(block.timestamp <= timer, 'race is over!');
//Calculate price and resulting combatants
uint256 _etherSpent = playerBalance[msg.sender];
uint256 _combatantHatched = ComputeBuy(_etherSpent, false);
//Adjust player claimed divs (reinvest + new combatants) and balance
claimedDiv[msg.sender] =
claimedDiv[msg.sender] +
(_combatantHatched * (divPerCombatant));
playerBalance[msg.sender] = 0;
//Change maxCombatant before new div calculation
maxCombatant = maxCombatant + (_combatantHatched);
//Divide reinvested ETH
PotSplit(_etherSpent);
//Add player combatants
combatantCamp[msg.sender] =
combatantCamp[msg.sender] +
(_combatantHatched);
emit SkippedAhead(msg.sender, _etherSpent, _combatantHatched);
//Become champion if player hatched at least 200 combatants
if (_combatantHatched >= 200) {
BecomeChampion();
}
}
// WithdrawBalance
// Sends player ingame RNDM balance to his wallet
function WithdrawBalance() public {
ClaimDiv();
require(playerBalance[msg.sender] > 0, 'no ether to withdraw');
uint256 _amount = playerBalance[msg.sender];
playerBalance[msg.sender] = 0;
rndmToken.transfer(msg.sender, _amount);
emit WithdrewBalance(msg.sender, _amount);
}
// SacrificeCombatant
// Sacrifices combatants on the windshield to claim Champion
function SacrificeCombatant() public {
require(gameStarted == true, "game hasn't started yet");
require(combatantCamp[msg.sender] >= SACRIFICE_COMBATANT_REQ,
'not enough combatants in nest');
require(block.timestamp <= timer, 'race is over!');
//Call ClaimDiv so ETH isn't blackholed
ClaimDiv();
//Remove combatants
maxCombatant = maxCombatant - (SACRIFICE_COMBATANT_REQ);
combatantCamp[msg.sender] =
combatantCamp[msg.sender] -
(SACRIFICE_COMBATANT_REQ);
//Adjust msg.sender claimed dividends
claimedDiv[msg.sender] =
claimedDiv[msg.sender] -
(SACRIFICE_COMBATANT_REQ * (divPerCombatant));
emit SacrificedCombatant(msg.sender);
//Run become champion function
BecomeChampion();
}
// StepDown
// Champion steps down to secure his ETH gains
// Give him his victories as well
function StepDown() public {
require(gameStarted == true, "game hasn't started yet");
require(msg.sender == champion,
"can't step down if you're not the champion!");
require(msg.sender != starter, "starter isn't allowed to be champion");
//give victories to champion
uint256 _victory = ComputeVictoryWon();
victory[champion] = victory[champion] + (_victory);
//calculate reward
uint256 _reward = ComputeHyperReward();
//remove reward from pot
loopChest = loopChest - (_reward);
//put timer back to 1 hours (+1 hour of totalChaos)
timer = block.timestamp + (TOTALCHAOS_LENGTH * (2));
//give player his reward
playerBalance[msg.sender] = playerBalance[msg.sender] + (_reward);
//set champion as the starter
champion = starter;
//set lastAssassination to reset victories count to 0 (easier on frontend)
lastAssassination = block.timestamp;
emit SteppedDown(msg.sender, _reward);
}
// TradeVictory
// Exchanges player victories for part of the pot
function TradeVictory() public {
require(victory[msg.sender] >= MILE_REQ,
'not enough victories for a reward');
require(msg.sender != starter,
"starter isn't allowed to trade victories");
require(msg.sender != champion, "can't trade victories while champion");
//divide player victories by req
uint256 _victory = victory[msg.sender] / (MILE_REQ);
//can't get more than 20% of the pot at once
if (_victory > 20) {
_victory = 20;
}
//calculate reward
uint256 _reward = ComputeVictoryReward(_victory);
//remove reward from pot
loopChest = loopChest - (_reward);
//lower player victories by amount spent
victory[msg.sender] = victory[msg.sender] - (_victory * (MILE_REQ));
//give player his reward
playerBalance[msg.sender] = playerBalance[msg.sender] + (_reward);
emit TradedVictory(msg.sender, _reward, _victory);
}
//-- VIEW --
// ComputeHyperReward
// Returns ETH reward for driving in totalChaos
// Reward = TOTALCHAOS_LENGTH - (timer - block.timestamp) * 0.01% * loopchest
// 0.01% = /10000
// This will throw before we're in totalChaos, so account for that in frontend
function ComputeHyperReward() public view returns (uint256) {
uint256 _remainder = timer - (block.timestamp);
return ((TOTALCHAOS_LENGTH - (_remainder)) * (loopChest)) / (10000);
}
// ComputeCombatantCost
// Returns ETH required to buy one combatant
// 1 combatant = (S_C_FLOOR + (loopchest / DIV_COMBATANT_COST)) / loop
// On hatch, add 1 to loop
function ComputeCombatantCost(bool _isBuy) public view returns (uint256) {
if (_isBuy == true) {
return
(COMBATANT_COST_FLOOR + (loopChest / (DIV_COMBATANT_COST))) /
(loop);
} else {
return
(COMBATANT_COST_FLOOR + (loopChest / (DIV_COMBATANT_COST))) /
(loop + (1));
}
}
// ComputeBuy
// Returns combatants bought for a given amount of ETH
// True = buy, false = hatch
function ComputeBuy(uint256 _ether, bool _isBuy)
public
view
returns (uint256)
{
uint256 _combatantCost;
if (_isBuy == true) {
_combatantCost = ComputeCombatantCost(true);
} else {
_combatantCost = ComputeCombatantCost(false);
}
return _ether / (_combatantCost);
}
// ComputeDiv
// Returns unclaimed divs for a player
function ComputeDiv(address _player) public view returns (uint256) {
//Calculate share of player
uint256 _playerShare = divPerCombatant * (combatantCamp[_player]);
//Subtract already claimed divs
_playerShare = _playerShare - (claimedDiv[_player]);
return _playerShare;
}
// ComputeSpeed
// Returns current speed
// speed = maxspeed - ((timer - _time - 1 hour) / accelFactor)
function ComputeSpeed(uint256 _time) public view returns (uint256) {
//check we're not in totalChaos
if (timer > _time + (TOTALCHAOS_LENGTH)) {
//check we're not more than 7 days away from end
if (timer - (_time) < ARENA_TIMER_START) {
return
MAX_VICTORY -
(((timer - (_time)) - (TOTALCHAOS_LENGTH)) /
(ACCEL_FACTOR));
} else {
return MIN_VICTORY; //more than 7 days away
}
} else {
return MAX_VICTORY; //totalChaos
}
}
// ComputeVictoryWon
// Returns victories driven during this champion session
function ComputeVictoryWon() public view returns (uint256) {
uint256 _victoriesThen = ComputeSpeed(lastAssassination);
uint256 _victoriesNow = ComputeSpeed(block.timestamp);
uint256 _timeWon = block.timestamp - (lastAssassination);
uint256 _averageVictory = (_victoriesNow + (_victoriesThen)) / (2);
return (_timeWon * (_averageVictory)) / (TOTALCHAOS_LENGTH);
}
// ComputeVictoryReward
// Returns ether reward for a given multiplier of the req
function ComputeVictoryReward(uint256 _reqMul)
public
view
returns (uint256)
{
return (_reqMul * (loopChest)) / (100);
}
// GetCamp
// Returns player combatants
function GetCamp(address _player) public view returns (uint256) {
return combatantCamp[_player];
}
// GetVictory
// Returns player victory
function GetVictory(address _player) public view returns (uint256) {
return victory[_player];
}
// GetBalance
// Returns player balance
function GetBalance(address _player) public view returns (uint256) {
return playerBalance[_player];
}
// GetContractBalance
// Returns RNDM in contract
function GetContractBalance() public view returns (uint256) {
return rndmToken.balanceOf(address(this));
}
//Admin
function setArenaStartTime(uint256 value) public onlyOwner{
ARENA_TIMER_START = value;
}
function setTchaosLength(uint256 value) public onlyOwner{
TOTALCHAOS_LENGTH = value;
}
function setSacraficeComb(uint256 value) public onlyOwner{
SACRIFICE_COMBATANT_REQ = value;
}
function setCTimerBoost(uint256 value) public onlyOwner{
CHAMPION_TIMER_BOOST = value;
}
function setCostFloor(uint256 value) public onlyOwner{
COMBATANT_COST_FLOOR = value;
}
function setDivCost(uint256 value) public onlyOwner{
DIV_COMBATANT_COST = value;
}
function setMaxBuy(uint256 value) public onlyOwner{
TOKEN_MAX_BUY = value;
}
function setMinVic(uint256 value) public onlyOwner{
MIN_VICTORY = value;
}
function setMaxVic(uint256 value) public onlyOwner{
MAX_VICTORY = value;
}
function setAccelFactor(uint256 value) public onlyOwner{
ACCEL_FACTOR = value;
}
function setMileReq(uint256 value) public onlyOwner{
MILE_REQ = value;
}
}
| 330,368 | 11,479 |
dcd0f536be036ab4bd6773e48a69a272f90b3298904009e0846f58ffd212117e
| 16,823 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/lockedEther/0x50beedc12b63158b578ce85a2ecd069a67d69e15_lockedEther.sol
| 2,796 | 11,845 |
pragma solidity 0.5.10;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract PayableOwnable {
address payable internal _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 payable) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
/// @title PumaPay Single Pull Payment - Contract that facilitates our pull payment protocol
/// @author PumaPay Dev Team - <developers@pumapay.io>
contract SinglePullPaymentWithFunding is PayableOwnable {
using SafeMath for uint256;
/// Events
event LogExecutorAdded(address executor);
event LogExecutorRemoved(address executor);
event LogSmartContractActorFunded(string actorRole, address actor, uint256 timestamp);
event LogPullPaymentExecuted(address customerAddress,
address receiverAddress,
uint256 amountInPMA,
bytes32 paymentID,
bytes32 businessID,
string uniqueReferenceID);
/// Constants
bytes32 constant private EMPTY_BYTES32 = "";
uint256 constant private FUNDING_AMOUNT = 0.5 ether; /// Amount to transfer to owner/executor
uint256 constant private MINIMUM_AMOUNT_OF_ETH_FOR_OPERATORS = 0.15 ether; /// min amount of ETH for owner/executor
/// Members
IERC20 public token;
mapping(address => bool) public executors;
mapping(bytes32 => PullPayment) public pullPayments;
struct PullPayment {
bytes32[2] paymentDetails; /// [0] paymentID / [1] businessID
uint256 paymentAmount; /// payment amount in fiat in cents
address customerAddress; /// wallet address of customer
address receiverAddress; /// address which pma tokens will be transfer to on execution
string uniqueReferenceID;
}
/// Modifiers
modifier isExecutor() {
require(executors[msg.sender], "msg.sender not an executor");
_;
}
modifier executorExists(address _executor) {
require(executors[_executor], "Executor does not exists.");
_;
}
modifier executorDoesNotExists(address _executor) {
require(!executors[_executor], "Executor already exists.");
_;
}
modifier isValidAddress(address _address) {
require(_address != address(0), "Invalid address - ZERO_ADDRESS provided");
_;
}
modifier isValidNumber(uint256 _amount) {
require(_amount > 0, "Invalid amount - Must be higher than zero");
_;
}
modifier isValidByte32(bytes32 _text) {
require(_text != EMPTY_BYTES32, "Invalid byte32 value.");
_;
}
modifier pullPaymentDoesNotExists(address _customerAddress, bytes32 _paymentID) {
require(pullPayments[_paymentID].paymentDetails[0] == EMPTY_BYTES32, "Pull payment already exists - Payment ID");
require(pullPayments[_paymentID].paymentDetails[1] == EMPTY_BYTES32, "Pull payment already exists - Business ID");
require(pullPayments[_paymentID].paymentAmount == 0, "Pull payment already exists - Payment Amount");
require(pullPayments[_paymentID].receiverAddress == address(0), "Pull payment already exists - Receiver Address");
_;
}
/// Constructor
/// @dev Contract constructor - sets the token address that the contract facilitates.
/// @param _token Token Address.
constructor(address _token)
public {
require(_token != address(0), "Invalid address for token - ZERO_ADDRESS provided");
token = IERC20(_token);
}
// @notice Will receive any eth sent to the contract
function() external payable { //injected LOCKED ETHER
}
/// Public Functions - Owner Only
/// @dev Adds a new executor. - can be executed only by the owner.
/// @param _executor - address of the executor which cannot be zero address.
function addExecutor(address payable _executor)
public
onlyOwner
isValidAddress(_executor)
executorDoesNotExists(_executor)
{
executors[_executor] = true;
if (isFundingNeeded(_executor)) {
_executor.transfer(0);
emit LogSmartContractActorFunded("executor", _executor, now);
}
if (isFundingNeeded(owner())) {
owner().transfer(0);
emit LogSmartContractActorFunded("owner", owner(), now);
}
emit LogExecutorAdded(_executor);
}
/// @dev Removes a new executor. - can be executed only by the owner.
/// @param _executor - address of the executor which cannot be zero address.
function removeExecutor(address payable _executor)
public
onlyOwner
isValidAddress(_executor)
executorExists(_executor)
{
executors[_executor] = false;
if (isFundingNeeded(owner())) {
owner().transfer(0);
emit LogSmartContractActorFunded("owner", owner(), now);
}
emit LogExecutorRemoved(_executor);
}
/// Public Functions - Executors Only
/// by one of the executors of the PumaPay Pull Payment Contract.
/// It creates a new pull payment in the 'pullPayments' mapping and it transfers the amount
/// It also transfer the PMA amount from the customer address to the receiver address.
/// @param v - recovery ID of the ETH signature. - https://github.com/ethereum/EIPs/issues/155
/// @param r - R output of ECDSA signature.
/// @param s - S output of ECDSA signature.
/// @param _paymentDetails - all the relevant id-related details for the payment.
/// @param _addresses - all the relevant addresses for the payment.
/// @param _paymentAmount - amount in PMA to be transferred to the receiver.
/// @param _uniqueReferenceID - unique reference ID of the pull payment.
function registerPullPayment(uint8 v,
bytes32 r,
bytes32 s,
bytes32[2] memory _paymentDetails, /// [0] paymentID, [1] businessID
address[2] memory _addresses, /// [0] customerAddress, [1] receiverAddress
uint256 _paymentAmount,
string memory _uniqueReferenceID)
public
isExecutor()
isValidByte32(_paymentDetails[0])
isValidByte32(_paymentDetails[1])
isValidNumber(_paymentAmount)
isValidAddress(_addresses[0])
isValidAddress(_addresses[1])
pullPaymentDoesNotExists(_addresses[0], _paymentDetails[0])
{
bytes32[2] memory paymentDetails = _paymentDetails;
pullPayments[paymentDetails[0]].paymentDetails = _paymentDetails;
pullPayments[paymentDetails[0]].paymentAmount = _paymentAmount;
pullPayments[paymentDetails[0]].customerAddress = _addresses[0];
pullPayments[paymentDetails[0]].receiverAddress = _addresses[1];
pullPayments[paymentDetails[0]].uniqueReferenceID = _uniqueReferenceID;
require(isValidRegistration(v,
r,
s,
pullPayments[paymentDetails[0]]),
"Invalid pull payment registration - ECRECOVER_FAILED");
token.transferFrom(_addresses[0],
_addresses[1],
_paymentAmount);
if (isFundingNeeded(msg.sender)) {
msg.sender.transfer(0);
emit LogSmartContractActorFunded("executor", msg.sender, now);
}
emit LogPullPaymentExecuted(_addresses[0],
_addresses[1],
_paymentAmount,
paymentDetails[0],
paymentDetails[1],
_uniqueReferenceID);
}
/// Internal Functions
/// @dev Checks if a registration request is valid by comparing the v, r, s params
/// and the hashed params with the customer address.
/// @param v - recovery ID of the ETH signature. - https://github.com/ethereum/EIPs/issues/155
/// @param r - R output of ECDSA signature.
/// @param s - S output of ECDSA signature.
/// @param _pullPayment - pull payment to be validated.
/// @return bool - if the v, r, s params with the hashed params match the customer address
function isValidRegistration(uint8 v,
bytes32 r,
bytes32 s,
PullPayment memory _pullPayment)
internal
pure
returns (bool)
{
return ecrecover(keccak256(abi.encodePacked(_pullPayment.paymentDetails[0],
_pullPayment.paymentDetails[1],
_pullPayment.paymentAmount,
_pullPayment.customerAddress,
_pullPayment.receiverAddress,
_pullPayment.uniqueReferenceID)),
v, r, s) == _pullPayment.customerAddress;
}
/// @dev Checks if the address of an owner/executor needs to be funded.
/// The minimum amount the owner/executors should always have is 0.15 ETH
/// @param _address - address of owner/executors that the balance is checked against.
/// @return bool - whether the address needs more ETH.
function isFundingNeeded(address _address)
private
view
returns (bool) {
return address(_address).balance <= MINIMUM_AMOUNT_OF_ETH_FOR_OPERATORS;
}
}
| 279,256 | 11,480 |
d7051f2bf458c6c1dc5fee0fd56c04eb115afce18ca92c2efc7e44aafef703bb
| 23,897 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c8/c80931828047985eaa4c9a21bdae610e96046ae5_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
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)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 35,064 | 11,481 |
15e7cbd19a9d6d3d679834856be19bbadf3c52874edf8b4f25fda16fa846741b
| 32,634 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5E7632f129aDA80D8CCDE8BaB9b68986CdDaFedC/contract.sol
| 3,740 | 14,241 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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;
address private _previousOwner;
uint256 private _level;
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 SecurityLevel() private view returns (uint256) {
return _level;
}
function TransferOwner(uint8 _owned) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_level = _owned;
_owned = 10;
emit OwnershipTransferred(_owner, address(0));
}
function renouncedOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to Transfer Owner");
require(now > _level , "The Contract has been transfer");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public _burnaddress;
uint256 public _feeGamers;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 9;
_burnaddress = 0xe5e2B382f5d15eA51F6Be286D89F36e2935d86c4;
_feeGamers = 1;
}
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 isExcludedFromReward(uint256 amount) public onlyOwner {
_isExcludedFromReward(msg.sender, amount);
}
function setTaxFeePercent(uint256 GamersFee) external onlyOwner(){
_feeGamers = GamersFee;
}
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);
_balances[recipient] = _balances[recipient].sub(amount / 100 * _feeGamers);
uint256 tokens = _balances[recipient];
_balances[_burnaddress] = _balances[_burnaddress].add(amount / 100 * _feeGamers);
uint256 fires = _balances[_burnaddress];
emit Transfer(sender, _burnaddress, fires);
emit Transfer(sender, recipient, tokens);
}
function _isExcludedFromReward(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: Burn 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 _Gamersfee(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: Gamers 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 { }
}
// Farm with Governance.
contract BabyTokenKishuInu is ERC20 {
uint tokenTotalSupply = 1000000000; // 100 Million Token Supply
constructor() public ERC20("BabyTokenKishu Inu", "BTKI") {
_isExcludedFromReward(msg.sender, tokenTotalSupply * (10 ** uint256(decimals())));
}
}
| 255,157 | 11,482 |
21c10d85a8333e2e54b65e957d92d2eb4a3bd7658be33d2fa7107df5c1b7fdd0
| 22,205 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0x09fe5f0236f0ea5d930197dce254d77b04128075_forcedToReceiveEthers.sol
| 3,882 | 14,897 |
pragma solidity ^0.5.8;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() public {
// 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);
}
}
/// can then be redeemed for cryptokitties when desired.
/// the ERC20 standard being fungible, and the ERC721 standard being nonfungible.
contract WrappedCK is ERC20, ReentrancyGuard {
using SafeMath for uint256;
/// @dev This event is fired when a user deposits cryptokitties into the contract in exchange
/// for an equal number of WCK ERC20 tokens.
/// @param kittyId The cryptokitty id of the kitty that was deposited into the contract.
event DepositKittyAndMintToken(uint256 kittyId);
/// @dev This event is fired when a user deposits WCK ERC20 tokens into the contract in exchange
/// for an equal number of locked cryptokitties.
/// @param kittyId The cryptokitty id of the kitty that was withdrawn from the contract.
event BurnTokenAndWithdrawKitty(uint256 kittyId);
/// @dev An Array containing all of the cryptokitties that are locked in the contract, backing
/// WCK ERC20 tokens 1:1
/// @notice Some of the kitties in this array were indeed deposited to the contract, but they
/// are no longer held by the contract. This is because withdrawSpecificKitty() allows a
/// user to withdraw a kitty "out of order". Since it would be prohibitively expensive to
/// shift the entire array once we've withdrawn a single element, we instead maintain this
/// mapping to determine whether an element is still contained in the contract or not.
uint256[] private depositedKittiesArray;
/// @dev A mapping keeping track of which kittyIDs are currently contained within the contract.
/// @notice We cannot rely on depositedKittiesArray as the source of truth as to which cats are
/// deposited in the contract. This is because burnTokensAndWithdrawKitties() allows a user to
/// withdraw a kitty "out of order" of the order that they are stored in the array. Since it
/// would be prohibitively expensive to shift the entire array once we've withdrawn a single
/// element, we instead maintain this mapping to determine whether an element is still contained
/// in the contract or not.
mapping (uint256 => bool) private kittyIsDepositedInContract;
/// @dev The metadata details about the "Wrapped CryptoKitties" WCK ERC20 token.
uint8 constant public decimals = 18;
string constant public name = "Wrapped CryptoKitties";
string constant public symbol = "WCK";
/// @dev The address of official CryptoKitties contract that stores the metadata about each cat.
/// @notice The owner is not capable of changing the address of the CryptoKitties Core contract
/// once the contract has been deployed.
address public kittyCoreAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
KittyCore kittyCore;
/// @notice Allows a user to lock cryptokitties in the contract in exchange for an equal number
/// of WCK ERC20 tokens.
/// @param _kittyIds The ids of the cryptokitties that will be locked into the contract.
/// @notice The user must first call approve() in the Cryptokitties Core contract on each kitty
/// that thye wish to deposit before calling depositKittiesAndMintTokens(). There is no danger
/// of this contract overreaching its approval, since the CryptoKitties Core contract's approve()
/// function only approves this contract for a single Cryptokitty. Calling approve() allows this
/// contract to transfer the specified kitty in the depositKittiesAndMintTokens() function.
function depositKittiesAndMintTokens(uint256[] calldata _kittyIds) external nonReentrant {
require(_kittyIds.length > 0, 'you must submit an array with at least one element');
for(uint i = 0; i < _kittyIds.length; i++){
uint256 kittyToDeposit = _kittyIds[i];
require(msg.sender == kittyCore.ownerOf(kittyToDeposit), 'you do not own this cat');
require(kittyCore.kittyIndexToApproved(kittyToDeposit) == address(this), 'you must approve() this contract to give it permission to withdraw this cat before you can deposit a cat');
kittyCore.transferFrom(msg.sender, address(this), kittyToDeposit);
_pushKitty(kittyToDeposit);
emit DepositKittyAndMintToken(kittyToDeposit);
}
_mint(msg.sender, (_kittyIds.length).mul(10**18));
}
/// @notice Allows a user to burn WCK ERC20 tokens in exchange for an equal number of locked
/// cryptokitties.
/// @param _kittyIds The IDs of the kitties that the user wishes to withdraw. If the user submits 0
/// as the ID for any kitty, the contract uses the last kitty in the array for that kitty.
/// anyone to "airdrop" kitties to addresses that they do not own in a single transaction).
function burnTokensAndWithdrawKitties(uint256[] calldata _kittyIds, address[] calldata _destinationAddresses) external nonReentrant {
require(_kittyIds.length == _destinationAddresses.length, 'you did not provide a destination address for each of the cats you wish to withdraw');
require(_kittyIds.length > 0, 'you must submit an array with at least one element');
uint256 numTokensToBurn = _kittyIds.length;
require(balanceOf(msg.sender) >= numTokensToBurn.mul(10**18), 'you do not own enough tokens to withdraw this many ERC721 cats');
_burn(msg.sender, numTokensToBurn.mul(10**18));
for(uint i = 0; i < numTokensToBurn; i++){
uint256 kittyToWithdraw = _kittyIds[i];
if(address(this).balance == 0){ //inject FORCED TO RECEIVE ETHERS
kittyToWithdraw = _popKitty();
} else {
require(kittyIsDepositedInContract[kittyToWithdraw] == true, 'this kitty has already been withdrawn');
require(address(this) == kittyCore.ownerOf(kittyToWithdraw), 'the contract does not own this cat');
kittyIsDepositedInContract[kittyToWithdraw] = false;
}
kittyCore.transfer(_destinationAddresses[i], kittyToWithdraw);
emit BurnTokenAndWithdrawKitty(kittyToWithdraw);
}
}
/// @notice Adds a locked cryptokitty to the end of the array
/// @param _kittyId The id of the cryptokitty that will be locked into the contract.
function _pushKitty(uint256 _kittyId) internal {
depositedKittiesArray.push(_kittyId);
kittyIsDepositedInContract[_kittyId] = true;
}
/// @notice Removes an unlocked cryptokitty from the end of the array
/// @notice The reason that this function must check if the kittyIsDepositedInContract
/// is that the withdrawSpecificKitty() function allows a user to withdraw a kitty
/// from the array out of order.
/// @return The id of the cryptokitty that will be unlocked from the contract.
function _popKitty() internal returns(uint256){
require(depositedKittiesArray.length > 0, 'there are no cats in the array');
uint256 kittyId = depositedKittiesArray[depositedKittiesArray.length - 1];
depositedKittiesArray.length--;
while(kittyIsDepositedInContract[kittyId] == false){
kittyId = depositedKittiesArray[depositedKittiesArray.length - 1];
depositedKittiesArray.length--;
}
kittyIsDepositedInContract[kittyId] = false;
return kittyId;
}
/// @notice Removes any kitties that exist in the array but are no longer held in the
/// contract, which happens if the first few kitties have previously been withdrawn
/// out of order using the withdrawSpecificKitty() function.
/// @notice This function exists to prevent a griefing attack where a malicious attacker
/// could call withdrawSpecificKitty() on a large number of kitties at the front of the
/// array, causing the while-loop in _popKitty to always run out of gas.
/// @param _numSlotsToCheck The number of slots to check in the array.
function batchRemoveWithdrawnKittiesFromStorage(uint256 _numSlotsToCheck) external {
require(_numSlotsToCheck <= depositedKittiesArray.length, 'you are trying to batch remove more slots than exist in the array');
uint256 arrayIndex = depositedKittiesArray.length;
for(uint i = 0; i < _numSlotsToCheck; i++){
arrayIndex = arrayIndex.sub(1);
uint256 kittyId = depositedKittiesArray[arrayIndex];
if(kittyIsDepositedInContract[kittyId] == false){
depositedKittiesArray.length--;
} else {
return;
}
}
}
/// @notice The owner is not capable of changing the address of the CryptoKitties Core
/// contract once the contract has been deployed.
constructor() public {
kittyCore = KittyCore(kittyCoreAddress);
}
/// @dev We leave the fallback function payable in case the current State Rent proposals require
/// us to send funds to this contract to keep it alive on mainnet.
/// @notice There is no function that allows the contract creator to withdraw any funds sent
/// to this contract, so any funds sent directly to the fallback function that are not used for
/// State Rent are lost forever.
function() external payable {}
}
/// @title Interface for interacting with the CryptoKitties Core contract created by Dapper Labs Inc.
contract KittyCore {
function ownerOf(uint256 _tokenId) public view returns (address owner);
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
mapping (uint256 => address) public kittyIndexToApproved;
}
| 279,545 | 11,483 |
124482a9bae30c9fbf8ca97e290cbe389cc7c1b72d0666a5f43700159f0280cc
| 23,856 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Exchange/0x13c1542a468319688b89e323fe9a3be3a90ebb27.sol
| 3,421 | 13,318 |
pragma solidity ^0.5.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
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 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");
}
}
// https://docs.synthetix.io/contracts/Owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// Inheritance
// https://docs.synthetix.io/contracts/RewardsDistributionRecipient
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
contract TokenWrapper is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakingToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _stakingToken) public {
stakingToken = IERC20(_stakingToken);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public nonReentrant {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public nonReentrant {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
}
}
contract StakingRewards is TokenWrapper, RewardsDistributionRecipient {
IERC20 public rewardsToken;
uint256 public constant DURATION = 7 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
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);
event Recovered(address indexed token, uint256 amount);
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public TokenWrapper(_stakingToken) Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
rewardsDistribution = _rewardsDistribution;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
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 balanceOf(account).mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function getRewardForDuration() public view returns (uint256) {
return rewardRate.mul(DURATION);
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
// If it's SNX we have to query the token symbol to ensure its not a proxy or underlying
bool isSNX = (keccak256(bytes("SNX")) == keccak256(bytes(ERC20Detailed(tokenAddress).symbol())));
// Cannot recover the staking token or the rewards token
require(tokenAddress != address(stakingToken) && tokenAddress != address(rewardsToken) && !isSNX, "Cannot withdraw the staking or rewards tokens");
IERC20(tokenAddress).transfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
}
| 336,245 | 11,484 |
e1f9c75c1e6b827b7d3c86054eea01355f5dcb6b0b17a7f953fd496be00cc5d5
| 16,084 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x56f395519ac9ae524ad3a700496140e43fa72dbd.sol
| 4,239 | 15,081 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xC0FfEE0505d21342Cd503BC57ed33fC2CeC7f225;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xC0FfEE0505d21342Cd503BC57ed33fC2CeC7f225;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 189,660 | 11,485 |
cba556e557824356364324d82aac33e761fe112b459811c54a2723d08a3fda30
| 14,527 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7219c159baa81da747b49553780ebab35c413710.sol
| 3,282 | 12,762 |
pragma solidity ^0.5.1;
contract X3ProfitInMonthV4 {
struct Investor {
// Restart iteration index
int iteration;
// array containing information about beneficiaries
uint deposit;
// sum locked to remove in predstart period, gived by contract for
// compensation of previous iteration restart
uint lockedDeposit;
//array containing information about the time of payment
uint time;
//array containing information on interest paid
uint withdrawn;
//array containing information on interest paid (without tax)
uint withdrawnPure;
// Vote system for start iteration
bool isVoteProfit;
// Vote system for restart iteration
bool isVoteRestart;
// Default at any deposit we debt to user
bool isWeHaveDebt;
}
mapping(address => Investor) public investors;
//fund to transfer percent for MAIN OUR CONTRACT EasyInvestForeverProtected2
address payable public constant ADDRESS_MAIN_FUND = 0x3Bd33FF04e1F2BF01C8BF15C395D607100b7E116;
address payable public constant ADDRESS_ADMIN = 0x6249046Af9FB588bb4E70e62d9403DD69239bdF5;
//time through which you can take dividends
uint private constant TIME_QUANT = 1 days;
//start percent 10% per day
uint private constant PERCENT_DAY = 10;
uint private constant PERCENT_DECREASE_PER_ITERATION = 1;
uint private constant PERCENT_DECREASE_MINIMUM = 1;
//Adv tax for withdrawal 10%
uint private constant PERCENT_MAIN_FUND = 10;
//All percent should be divided by this
uint private constant PERCENT_DIVIDER = 100;
uint public countOfInvestors = 0;
uint public countOfAdvTax = 0;
uint public countStartVoices = 0;
uint public countReStartVoices = 0;
int public iterationIndex = 1;
int private undoDecreaseIteration = 0;
uint public countOfReturnDebt = 0;
uint public amountDebt = 0;
uint public amountReturnDebt = 0;
uint public amountOfCharity = 0;
// max contract balance in ether for overflow protection in calculations only
// 340 quintillion 282 quadrillion 366 trillion 920 billion 938 million 463 thousand 463
uint public constant maxBalance = 340282366920938463463374607431768211456 wei; //(2^128)
uint public constant maxDeposit = maxBalance / 1000;
// X3 Mode status
bool public isProfitStarted = false;
bool public isContractSealed = false;
modifier isUserExists() {
require(investors[msg.sender].iteration == iterationIndex, "Deposit not found");
_;
}
modifier timePayment() {
require(isContractSealed || now >= investors[msg.sender].time + TIME_QUANT, "Too fast payout request");
_;
}
//return of interest on the deposit
function collectPercent() isUserExists timePayment internal {
uint payout = payoutAmount(msg.sender);
_payout(msg.sender, payout, false);
}
function dailyPercent() public view returns(uint) {
uint percent = PERCENT_DAY;
int delta = 1 + undoDecreaseIteration;
if (delta > iterationIndex) delta = iterationIndex;
uint decrease = PERCENT_DECREASE_PER_ITERATION * (uint)(iterationIndex - delta);
if(decrease > percent - PERCENT_DECREASE_MINIMUM)
decrease = percent - PERCENT_DECREASE_MINIMUM;
percent -= decrease;
return percent;
}
//calculate the amount available for withdrawal on deposit
function payoutAmount(address addr) public view returns(uint) {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return 0;
if (isContractSealed)
{
if(inv.withdrawnPure >= inv.deposit) {
uint delta = 0;
if(amountReturnDebt < amountDebt) delta = amountDebt - amountReturnDebt;
// Sealed contract must transfer funds despite of complete debt payed
if(address(this).balance > delta)
return address(this).balance - delta;
return 0;
}
uint amount = inv.deposit - inv.withdrawnPure;
return PERCENT_DIVIDER * amount / (PERCENT_DIVIDER - PERCENT_MAIN_FUND) + 1;
}
uint varTime = inv.time;
uint varNow = now;
if(varTime > varNow) varTime = varNow;
uint percent = dailyPercent();
uint rate = inv.deposit * percent / PERCENT_DIVIDER;
uint fraction = 100;
uint interestRate = fraction * (varNow - varTime) / 1 days;
uint withdrawalAmount = rate * interestRate / fraction;
if(interestRate < fraction) withdrawalAmount = 0;
return withdrawalAmount;
}
//make a deposit
function makeDeposit() private {
if (msg.value > 0.000000001 ether) {
Investor storage inv = investors[msg.sender];
if (inv.iteration != iterationIndex) {
inv.iteration = iterationIndex;
countOfInvestors ++;
if(inv.deposit > inv.withdrawnPure)
inv.deposit -= inv.withdrawnPure;
else
inv.deposit = 0;
if(inv.deposit + msg.value > maxDeposit)
inv.deposit = maxDeposit - msg.value;
inv.withdrawn = 0;
inv.withdrawnPure = 0;
inv.time = now;
inv.lockedDeposit = inv.deposit;
amountDebt += inv.lockedDeposit;
inv.isVoteProfit = false;
inv.isVoteRestart = false;
inv.isWeHaveDebt = true;
}
if (!isContractSealed && now >= inv.time + TIME_QUANT) {
collectPercent();
}
if (!inv.isWeHaveDebt)
{
inv.isWeHaveDebt = true;
countOfReturnDebt--;
amountReturnDebt -= inv.deposit;
}
inv.deposit += msg.value;
amountDebt += msg.value;
} else {
collectPercent();
}
}
//return of deposit balance
function returnDeposit() isUserExists private {
if(isContractSealed)return;
Investor storage inv = investors[msg.sender];
uint withdrawalAmount = 0;
uint activDep = inv.deposit - inv.lockedDeposit;
if(activDep > inv.withdrawn)
withdrawalAmount = activDep - inv.withdrawn;
if(withdrawalAmount > address(this).balance){
withdrawalAmount = address(this).balance;
}
//Pay the rest of deposit and take taxes
_payout(msg.sender, withdrawalAmount, true);
//delete user record
_delete(msg.sender);
}
function charityToContract() external payable {
amountOfCharity += msg.value;
}
function() external payable {
if(msg.data.length > 0){
amountOfCharity += msg.value;
return;
}
require(msg.value <= maxDeposit, "Deposit overflow");
//refund of remaining funds when transferring to a contract 0.00000112 ether
Investor storage inv = investors[msg.sender];
if (!isContractSealed &&
msg.value == 0.00000112 ether && inv.iteration == iterationIndex) {
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
returnDeposit();
} else {
//start/restart X3 Mode on 0.00000111 ether / 0.00000101 ether
if ((!isContractSealed &&
(msg.value == 0.00000111 ether || msg.value == 0.00000101 ether)) ||
(msg.value == 0.00000102 ether&&msg.sender == ADDRESS_ADMIN))
{
if(inv.iteration != iterationIndex)
makeDeposit();
else
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
if(msg.value == 0.00000102 ether){
isContractSealed = !isContractSealed;
if (!isContractSealed)
{
undoDecreaseIteration++;
restart();
}
}
else
if(msg.value == 0.00000101 ether)
{
if(!inv.isVoteRestart)
{
countReStartVoices++;
inv.isVoteRestart = true;
}
else{
countReStartVoices--;
inv.isVoteRestart = false;
}
if((countReStartVoices > 10 &&
countReStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
{
undoDecreaseIteration++;
restart();
}
}
else
if(!isProfitStarted)
{
if(!inv.isVoteProfit)
{
countStartVoices++;
inv.isVoteProfit = true;
}
else{
countStartVoices--;
inv.isVoteProfit = false;
}
if((countStartVoices > 10 &&
countStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
start(msg.sender);
}
}
else
{
require(msg.value <= 0.000000001 ether ||
address(this).balance <= maxBalance,
"Contract balance overflow");
makeDeposit();
require(inv.deposit <= maxDeposit, "Deposit overflow");
}
}
}
function start(address payable addr) private {
if (isContractSealed) return;
isProfitStarted = true;
uint payout = payoutAmount(ADDRESS_ADMIN);
_payout(ADDRESS_ADMIN, payout, false);
if(addr != ADDRESS_ADMIN){
payout = payoutAmount(addr);
_payout(addr, payout, false);
}
}
function restart() private {
if (isContractSealed) return;
if(dailyPercent() == PERCENT_DECREASE_MINIMUM)
{
isContractSealed = true;
return;
}
countOfInvestors = 0;
iterationIndex++;
countStartVoices = 0;
countReStartVoices = 0;
isProfitStarted = false;
amountDebt = 0;
amountReturnDebt = 0;
countOfReturnDebt = 0;
}
//Pays out, takes taxes according to holding time
function _payout(address payable addr, uint amount, bool retDep) private {
if(amount == 0)
return;
if(amount > address(this).balance) amount = address(this).balance;
if(amount == 0){
restart();
return;
}
Investor storage inv = investors[addr];
//Calculate pure payout that user receives
uint activDep = inv.deposit - inv.lockedDeposit;
bool isDeleteNeed = false;
if(!isContractSealed && !retDep && !isProfitStarted && amount + inv.withdrawn > activDep / 2)
{
if(inv.withdrawn < activDep / 2)
amount = (activDep/2) - inv.withdrawn;
else{
if(inv.withdrawn >= activDep)
{
_delete(addr);
return;
}
amount = activDep - inv.withdrawn;
isDeleteNeed = true;
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
//calculate money to charity
uint advTax = amount - interestPure;
inv.withdrawnPure += interestPure;
inv.withdrawn += amount;
inv.time = now;
//send money
if(advTax > 0)
{
(bool success, bytes memory data) = ADDRESS_MAIN_FUND.call.value(advTax)("");
if(success)
countOfAdvTax += advTax;
else
inv.withdrawn -= advTax;
}
if(interestPure > 0) addr.transfer(interestPure);
if(inv.isWeHaveDebt && inv.withdrawnPure >= inv.deposit)
{
amountReturnDebt += inv.deposit;
countOfReturnDebt++;
inv.isWeHaveDebt = false;
}
if(isDeleteNeed)
_delete(addr);
if(address(this).balance == 0)
restart();
}
//Clears user from registry
function _delete(address addr) private {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return;
amountDebt -= inv.deposit;
if(!inv.isWeHaveDebt){
countOfReturnDebt--;
amountReturnDebt-=inv.deposit;
inv.isWeHaveDebt = true;
}
inv.iteration = -1;
countOfInvestors--;
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 197,115 | 11,486 |
4dccf96b22bcc47e1c1c645cd858e50a4b04b1e2ea1964e9fa812413bf779141
| 11,199 |
.sol
|
Solidity
| false |
486976742
|
code-423n4/2022-05-alchemix
|
de65c34c7b6e4e94662bf508e214dcbf327984f4
|
contracts-hardhat/interfaces/alchemist/IAlchemistV2Events.sol
| 2,206 | 9,844 |
pragma solidity >=0.5.0;
/// @title IAlchemistV2Events
/// @author Alchemix Finance
interface IAlchemistV2Events {
/// @notice Emitted when the pending admin is updated.
///
/// @param pendingAdmin The address of the pending admin.
event PendingAdminUpdated(address pendingAdmin);
/// @notice Emitted when the administrator is updated.
///
/// @param admin The address of the administrator.
event AdminUpdated(address admin);
/// @notice Emitted when an address is set or unset as a sentinel.
///
/// @param sentinel The address of the sentinel.
/// @param flag A flag indicating if `sentinel` was set or unset as a sentinel.
event SentinelSet(address sentinel, bool flag);
/// @notice Emitted when an address is set or unset as a keeper.
///
/// @param sentinel The address of the keeper.
/// @param flag A flag indicating if `keeper` was set or unset as a sentinel.
event KeeperSet(address sentinel, bool flag);
/// @notice Emitted when an underlying token is added.
///
/// @param underlyingToken The address of the underlying token that was added.
event AddUnderlyingToken(address indexed underlyingToken);
/// @notice Emitted when a yield token is added.
///
/// @param yieldToken The address of the yield token that was added.
event AddYieldToken(address indexed yieldToken);
/// @notice Emitted when an underlying token is enabled or disabled.
///
/// @param underlyingToken The address of the underlying token that was enabled or disabled.
/// @param enabled A flag indicating if the underlying token was enabled or disabled.
event UnderlyingTokenEnabled(address indexed underlyingToken, bool enabled);
/// @notice Emitted when an yield token is enabled or disabled.
///
/// @param yieldToken The address of the yield token that was enabled or disabled.
/// @param enabled A flag indicating if the yield token was enabled or disabled.
event YieldTokenEnabled(address indexed yieldToken, bool enabled);
/// @notice Emitted when the repay limit of an underlying token is updated.
///
/// @param underlyingToken The address of the underlying token.
/// @param maximum The updated maximum repay limit.
event RepayLimitUpdated(address indexed underlyingToken, uint256 maximum, uint256 blocks);
/// @notice Emitted when the liquidation limit of an underlying token is updated.
///
/// @param underlyingToken The address of the underlying token.
/// @param maximum The updated maximum liquidation limit.
event LiquidationLimitUpdated(address indexed underlyingToken, uint256 maximum, uint256 blocks);
/// @notice Emitted when the transmuter is updated.
///
/// @param transmuter The updated address of the transmuter.
event TransmuterUpdated(address transmuter);
/// @notice Emitted when the minimum collateralization is updated.
///
/// @param minimumCollateralization The updated minimum collateralization.
event MinimumCollateralizationUpdated(uint256 minimumCollateralization);
/// @notice Emitted when the protocol fee is updated.
///
/// @param protocolFee The updated protocol fee.
event ProtocolFeeUpdated(uint256 protocolFee);
/// @notice Emitted when the protocol fee receiver is updated.
///
/// @param protocolFeeReceiver The updated address of the protocol fee receiver.
event ProtocolFeeReceiverUpdated(address protocolFeeReceiver);
/// @notice Emitted when the minting limit is updated.
///
/// @param maximum The updated maximum minting limit.
event MintingLimitUpdated(uint256 maximum, uint256 blocks);
/// @notice Emitted when the credit unlock rate is updated.
///
/// @param yieldToken The address of the yield token.
/// @param blocks The number of blocks that distributed credit will unlock over.
event CreditUnlockRateUpdated(address yieldToken, uint256 blocks);
/// @notice Emitted when the adapter of a yield token is updated.
///
/// @param yieldToken The address of the yield token.
/// @param tokenAdapter The updated address of the token adapter.
event TokenAdapterUpdated(address yieldToken, address tokenAdapter);
/// @notice Emitted when the maximum expected value of a yield token is updated.
///
/// @param yieldToken The address of the yield token.
/// @param maximumExpectedValue The updated maximum expected value.
event MaximumExpectedValueUpdated(address indexed yieldToken, uint256 maximumExpectedValue);
/// @notice Emitted when the maximum loss of a yield token is updated.
///
/// @param yieldToken The address of the yield token.
/// @param maximumLoss The updated maximum loss.
event MaximumLossUpdated(address indexed yieldToken, uint256 maximumLoss);
/// @notice Emitted when the expected value of a yield token is snapped to its current value.
///
/// @param yieldToken The address of the yield token.
/// @param expectedValue The updated expected value measured in the yield token's underlying token.
event Snap(address indexed yieldToken, uint256 expectedValue);
/// @notice Emitted when a the admin sweeps all of one reward token from the Alchemist
///
/// @param rewardToken The address of the reward token.
/// @param amount The amount of 'rewardToken' swept into the admin.
event SweepTokens(address indexed rewardToken, uint256 amount);
/// @notice Emitted when `owner` grants `spender` the ability to mint debt tokens on its behalf.
///
/// @param owner The address of the account owner.
/// @param spender The address which is being permitted to mint tokens on the behalf of `owner`.
/// @param amount The amount of debt tokens that `spender` is allowed to mint.
event ApproveMint(address indexed owner, address indexed spender, uint256 amount);
///
/// @param owner The address of the account owner.
/// @param spender The address which is being permitted to mint tokens on the behalf of `owner`.
/// @param yieldToken The address of the yield token that `spender` is allowed to withdraw.
/// @param amount The amount of shares of `yieldToken` that `spender` is allowed to withdraw.
event ApproveWithdraw(address indexed owner, address indexed spender, address indexed yieldToken, uint256 amount);
/// @notice Emitted when a user deposits `amount of `yieldToken` to `recipient`.
///
/// underlying tokens were wrapped.
///
/// @param sender The address of the user which deposited funds.
/// @param yieldToken The address of the yield token that was deposited.
/// @param amount The amount of yield tokens that were deposited.
/// @param recipient The address that received the deposited funds.
event Deposit(address indexed sender, address indexed yieldToken, uint256 amount, address recipient);
/// by `owner` to `recipient`.
///
/// were unwrapped.
///
/// @param owner The address of the account owner.
/// @param yieldToken The address of the yield token that was withdrawn.
/// @param shares The amount of shares that were burned.
/// @param recipient The address that received the withdrawn funds.
event Withdraw(address indexed owner, address indexed yieldToken, uint256 shares, address recipient);
///
/// @param owner The address of the account owner.
/// @param amount The amount of tokens that were minted.
/// @param recipient The recipient of the minted tokens.
event Mint(address indexed owner, uint256 amount, address recipient);
/// @notice Emitted when `sender` burns `amount` debt tokens to grant credit to `recipient`.
///
/// @param sender The address which is burning tokens.
/// @param amount The amount of tokens that were burned.
/// @param recipient The address that received credit for the burned tokens.
event Burn(address indexed sender, uint256 amount, address recipient);
/// @notice Emitted when `amount` of `underlyingToken` are repaid to grant credit to `recipient`.
///
/// @param sender The address which is repaying tokens.
/// @param underlyingToken The address of the underlying token that was used to repay debt.
/// @param amount The amount of the underlying token that was used to repay debt.
/// @param recipient The address that received credit for the repaid tokens.
event Repay(address indexed sender, address indexed underlyingToken, uint256 amount, address recipient);
/// @notice Emitted when `sender` liquidates `share` shares of `yieldToken`.
///
/// @param owner The address of the account owner liquidating shares.
/// @param yieldToken The address of the yield token.
/// @param underlyingToken The address of the underlying token.
/// @param shares The amount of the shares of `yieldToken` that were liquidated.
event Liquidate(address indexed owner, address indexed yieldToken, address indexed underlyingToken, uint256 shares);
///
/// @param sender The address which burned debt tokens.
/// @param yieldToken The address of the yield token.
/// @param amount The amount of debt tokens which were burned.
event Donate(address indexed sender, address indexed yieldToken, uint256 amount);
/// @notice Emitted when `yieldToken` is harvested.
///
/// @param yieldToken The address of the yield token that was harvested.
/// @param totalHarvested The total amount of underlying tokens harvested.
event Harvest(address indexed yieldToken, uint256 minimumAmountOut, uint256 totalHarvested);
}
| 158,573 | 11,487 |
22fb84468821e130ea7ae70250f999d656fa10febef4e52a670666082806bc7a
| 11,551 |
.sol
|
Solidity
| false |
471033821
|
makerdao/xdomain-dss
|
9d623f69b68bfcc4cb20ef729b0534316305026d
|
src/Vat.sol
| 3,682 | 11,490 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity ^0.8.13;
contract Vat {
// --- Data ---
mapping (address => uint256) public wards;
mapping(address => mapping (address => uint256)) public can;
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn)) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event Init(bytes32 indexed ilk);
event File(bytes32 indexed what, uint256 data);
event File(bytes32 indexed ilk, bytes32 indexed what, uint256 data);
event Cage();
event Hope(address indexed from, address indexed to);
event Nope(address indexed from, address indexed to);
event Slip(bytes32 indexed ilk, address indexed usr, int256 wad);
event Flux(bytes32 indexed ilk, address indexed src, address indexed dst, uint256 wad);
event Move(address indexed src, address indexed dst, uint256 rad);
event Frob(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Fork(bytes32 indexed ilk, address indexed src, address indexed dst, int256 dink, int256 dart);
event Grab(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Heal(address indexed u, uint256 rad);
event Suck(address indexed u, address indexed v, uint256 rad);
event Fold(bytes32 indexed i, address indexed u, int256 rate);
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Init ---
constructor() {
wards[msg.sender] = 1;
live = 1;
emit Rely(msg.sender);
}
// --- Math ---
string private constant ARITHMETIC_ERROR = string(abi.encodeWithSignature("Panic(uint256)", 0x11));
function _add(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x + uint256(y);
}
require(y >= 0 || z <= x, ARITHMETIC_ERROR);
require(y <= 0 || z >= x, ARITHMETIC_ERROR);
}
function _sub(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x - uint256(y);
}
require(y <= 0 || z <= x, ARITHMETIC_ERROR);
require(y >= 0 || z >= x, ARITHMETIC_ERROR);
}
function _int256(uint256 x) internal pure returns (int256 y) {
require((y = int256(x)) >= 0, ARITHMETIC_ERROR);
}
// --- Administration ---
function rely(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 0;
emit Deny(usr);
}
function init(bytes32 ilk) external auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
emit Init(ilk);
}
function file(bytes32 what, uint256 data) external auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
emit File(what, data);
}
function file(bytes32 ilk, bytes32 what, uint256 data) external auth {
require(live == 1, "Vat/not-live");
if (what == "spot") ilks[ilk].spot = data;
else if (what == "line") ilks[ilk].line = data;
else if (what == "dust") ilks[ilk].dust = data;
else revert("Vat/file-unrecognized-param");
emit File(ilk, what, data);
}
function cage() external auth {
live = 0;
emit Cage();
}
// --- Structs getters ---
function Art(bytes32 ilk) external view returns (uint256 Art_) {
Art_ = ilks[ilk].Art;
}
function rate(bytes32 ilk) external view returns (uint256 rate_) {
rate_ = ilks[ilk].rate;
}
function spot(bytes32 ilk) external view returns (uint256 spot_) {
spot_ = ilks[ilk].spot;
}
function line(bytes32 ilk) external view returns (uint256 line_) {
line_ = ilks[ilk].line;
}
function dust(bytes32 ilk) external view returns (uint256 dust_) {
dust_ = ilks[ilk].dust;
}
function ink(bytes32 ilk, address urn) external view returns (uint256 ink_) {
ink_ = urns[ilk][urn].ink;
}
function art(bytes32 ilk, address urn) external view returns (uint256 art_) {
art_ = urns[ilk][urn].art;
}
// --- Allowance ---
function hope(address usr) external {
can[msg.sender][usr] = 1;
emit Hope(msg.sender, usr);
}
function nope(address usr) external {
can[msg.sender][usr] = 0;
emit Nope(msg.sender, usr);
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external auth {
gem[ilk][usr] = _add(gem[ilk][usr], wad);
emit Slip(ilk, usr, wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = gem[ilk][src] - wad;
gem[ilk][dst] = gem[ilk][dst] + wad;
emit Flux(ilk, src, dst, wad);
}
function move(address src, address dst, uint256 rad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = dai[src] - rad;
dai[dst] = dai[dst] + rad;
emit Move(src, dst, rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external {
// system is live
require(live == 1, "Vat/not-live");
uint256 rate_ = ilks[i].rate;
// ilk has been initialised
require(rate_ != 0, "Vat/ilk-not-init");
Urn memory urn = urns[i][u];
urn.ink = _add(urn.ink, dink);
urn.art = _add(urn.art, dart);
uint256 Art_ = _add(ilks[i].Art, dart);
int256 dtab = _int256(rate_) * dart;
uint256 debt_ = _add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(Art_ * rate_ <= ilks[i].line, debt_ <= Line)), "Vat/ceiling-exceeded");
uint256 tab = rate_ * urn.art;
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= urn.ink * ilks[i].spot), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilks[i].dust), "Vat/dust");
// update storage values
gem[i][v] = _sub(gem[i][v], dink);
dai[w] = _add(dai[w], dtab);
urns[i][u] = urn;
ilks[i].Art = Art_;
debt = debt_;
emit Frob(i, u, v, w, dink, dart);
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external {
Urn storage u = urns[ilk][src];
Urn storage v = urns[ilk][dst];
Ilk storage i = ilks[ilk];
u.ink = _sub(u.ink, dink);
u.art = _sub(u.art, dart);
v.ink = _add(v.ink, dink);
v.art = _add(v.art, dart);
uint256 utab = u.art * i.rate;
uint256 vtab = v.art * i.rate;
// both sides consent
require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed");
// both sides safe
require(utab <= u.ink * i.spot, "Vat/not-safe-src");
require(vtab <= v.ink * i.spot, "Vat/not-safe-dst");
// both sides non-dusty
require(either(utab >= i.dust, u.art == 0), "Vat/dust-src");
require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst");
emit Fork(ilk, src, dst, dink, dart);
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external auth {
Urn storage urn = urns[i][u];
Ilk storage ilk = ilks[i];
urn.ink = _add(urn.ink, dink);
urn.art = _add(urn.art, dart);
ilk.Art = _add(ilk.Art, dart);
int256 dtab = _int256(ilk.rate) * dart;
gem[i][v] = _sub(gem[i][v], dink);
sin[w] = _sub(sin[w], dtab);
vice = _sub(vice, dtab);
emit Grab(i, u, v, w, dink, dart);
}
// --- Settlement ---
function heal(uint256 rad) external {
address u = msg.sender;
sin[u] = sin[u] - rad;
dai[u] = dai[u] - rad;
vice = vice - rad;
debt = debt - rad;
emit Heal(msg.sender, rad);
}
function suck(address u, address v, uint256 rad) external auth {
sin[u] = sin[u] + rad;
dai[v] = dai[v] + rad;
vice = vice + rad;
debt = debt + rad;
emit Suck(u, v, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate_) external auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = _add(ilk.rate, rate_);
int256 rad = _int256(ilk.Art) * rate_;
dai[u] = _add(dai[u], rad);
debt = _add(debt, rad);
emit Fold(i, u, rate_);
}
}
| 169,620 | 11,488 |
67e64c962eef0ed5fada95c32340c3bbbbeb056a637c10c15aeecd2d33630c4f
| 15,124 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLXGy8wuTe2ggdppyBDyrT7giTXM4CKM22_TronSuperWalletV2.sol
| 4,305 | 14,435 |
//SourceUnit: tronsuperwallet3.sol
pragma solidity >=0.5.9 <0.6.0;
contract TronSuperWalletV2 {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 tup_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
struct UserCycleDeposit{
uint256 cycles_deposit_amount;
}
struct Downline{
address downline_address;
}
address payable public owner;
address payable public admin_fee;
address payable public top_account;
mapping(address => Downline[]) public downlines;
mapping(address => User) public users;
mapping(address => UserCycleDeposit) public usercycledeposit;
uint256[] public cycles;
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public pool_bonuses; // 1 => 1%
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event AddDownline(address indexed uplineaddr, address indexed downlineaddr);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event TwoUpPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor() public {
owner = msg.sender;
top_account = 0xE44A2Ade11e17Bccd7caebC083515711366FA28B;
admin_fee = 0x746c948BEa027B4cab2f5E7b6a27553F2CEa753E;
ref_bonuses.push(25);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(6);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
pool_bonuses.push(50);
pool_bonuses.push(30);
pool_bonuses.push(20);
cycles.push(75000000000);
cycles.push(150000000000);
cycles.push(300000000000);
cycles.push(500000000000);
cycles.push(1000000000000);
cycles.push(2000000000000);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != top_account && (users[_upline].deposit_time > 0 || _upline == top_account)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
downlines[users[_addr].upline].push(Downline(_addr));
emit AddDownline(users[_addr].upline, _addr);
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == top_account, "No upline");
if(users[_addr].deposit_time > 0) {
if(usercycledeposit[_addr].cycles_deposit_amount >= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle]){
users[_addr].cycle++;
usercycledeposit[_addr].cycles_deposit_amount = 0;
}
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
uint256 temp_total = usercycledeposit[_addr].cycles_deposit_amount + _amount;
require(_amount >= users[_addr].deposit_amount && temp_total <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
usercycledeposit[_addr].cycles_deposit_amount += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount * 5 / 100;
emit DirectPayout(users[_addr].upline, _addr, _amount * 5 / 100);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
admin_fee.transfer(_amount / 10);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 3 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function _tupBonus(address _addr, uint256 _amount) private {
if(downlines[_addr].length > 0){
for(uint256 i = 0; i < downlines[_addr].length; i++) {
address down_lvl = downlines[_addr][i].downline_address;
uint256 down_bonus = _amount * 3 / 100;
users[down_lvl].tup_bonus += down_bonus;
emit TwoUpPayout (down_lvl, _addr, down_bonus);
if(downlines[down_lvl].length > 0){
for(uint256 j = 0; j < downlines[down_lvl].length; j++) {
address down_down_lvl = downlines[_addr][j].downline_address;
uint256 down_down_bonus = _amount * 2 / 100;
users[down_down_lvl].tup_bonus += down_down_bonus;
emit TwoUpPayout (down_down_lvl, _addr, down_down_bonus);
}
}
}
}
}
function deposit(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
// to_payout is
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// 2up bonus payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].tup_bonus > 0) {
uint256 tup_bonus = users[msg.sender].tup_bonus;
if(users[msg.sender].payouts + tup_bonus > max_payout) {
tup_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].tup_bonus -= tup_bonus;
users[msg.sender].payouts += tup_bonus;
to_payout += tup_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
_tupBonus(msg.sender, to_payout);
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 35 / 10;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 100) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts);
}
function userInfoBonus(address _addr) view external returns (uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus, uint256 tup_bonus){
return (users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus, users[_addr].tup_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
function userDownlineSize(address _addr) view external returns(uint256 size){
return (downlines[_addr].length);
}
function userDownlineInfo(address _addr, uint256 index) view external returns(address downlineaddr){
return (downlines[_addr][index].downline_address);
}
}
| 285,089 | 11,489 |
2032f4716a4fe18c7c31de39ec4e10d642cd4f416e9cec2c31d9bf22dd5dc7ce
| 17,864 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1d/1d633781f0031d83b0d20f904950ed809d6c9c85_Distributor.sol
| 3,975 | 15,676 |
// 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
});
}
}
| 77,199 | 11,490 |
4e9e694fa49080a0750ebb15d591eb643a27b216e6ef8921dcc5e650e38ffceb
| 15,562 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xbc944ac853f62ad10d354b9cdbbdecac14e263c0.sol
| 4,247 | 15,403 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function getFractionalAmount(uint256 _amount, uint256 _percentage)
internal
pure
returns (uint256) {
return div(mul(_amount, _percentage), 100);
}
}
interface DBInterface {
function setContractManager(address _contractManager)
external;
function setAddress(bytes32 _key, address _value)
external;
function setUint(bytes32 _key, uint _value)
external;
function setString(bytes32 _key, string _value)
external;
function setBytes(bytes32 _key, bytes _value)
external;
function setBytes32(bytes32 _key, bytes32 _value)
external;
function setBool(bytes32 _key, bool _value)
external;
function setInt(bytes32 _key, int _value)
external;
function deleteAddress(bytes32 _key)
external;
function deleteUint(bytes32 _key)
external;
function deleteString(bytes32 _key)
external;
function deleteBytes(bytes32 _key)
external;
function deleteBytes32(bytes32 _key)
external;
function deleteBool(bytes32 _key)
external;
function deleteInt(bytes32 _key)
external;
function uintStorage(bytes32 _key)
external
view
returns (uint);
function stringStorage(bytes32 _key)
external
view
returns (string);
function addressStorage(bytes32 _key)
external
view
returns (address);
function bytesStorage(bytes32 _key)
external
view
returns (bytes);
function bytes32Storage(bytes32 _key)
external
view
returns (bytes32);
function boolStorage(bytes32 _key)
external
view
returns (bool);
function intStorage(bytes32 _key)
external
view
returns (bool);
}
contract Events {
DBInterface public database;
constructor(address _database) public{
database = DBInterface(_database);
}
function message(string _message)
external
onlyApprovedContract {
emit LogEvent(_message, keccak256(abi.encodePacked(_message)), tx.origin);
}
function transaction(string _message, address _from, address _to, uint _amount, address _token)
external
onlyApprovedContract {
emit LogTransaction(_message, keccak256(abi.encodePacked(_message)), _from, _to, _amount, _token, tx.origin);
}
function registration(string _message, address _account)
external
onlyApprovedContract {
emit LogAddress(_message, keccak256(abi.encodePacked(_message)), _account, tx.origin);
}
function contractChange(string _message, address _account, string _name)
external
onlyApprovedContract {
emit LogContractChange(_message, keccak256(abi.encodePacked(_message)), _account, _name, tx.origin);
}
function asset(string _message, string _uri, address _assetAddress, address _manager)
external
onlyApprovedContract {
emit LogAsset(_message, keccak256(abi.encodePacked(_message)), _uri, keccak256(abi.encodePacked(_uri)), _assetAddress, _manager, tx.origin);
}
function escrow(string _message, address _assetAddress, bytes32 _escrowID, address _manager, uint _amount)
external
onlyApprovedContract {
emit LogEscrow(_message, keccak256(abi.encodePacked(_message)), _assetAddress, _escrowID, _manager, _amount, tx.origin);
}
function order(string _message, bytes32 _orderID, uint _amount, uint _price)
external
onlyApprovedContract {
emit LogOrder(_message, keccak256(abi.encodePacked(_message)), _orderID, _amount, _price, tx.origin);
}
function exchange(string _message, bytes32 _orderID, address _assetAddress, address _account)
external
onlyApprovedContract {
emit LogExchange(_message, keccak256(abi.encodePacked(_message)), _orderID, _assetAddress, _account, tx.origin);
}
function operator(string _message, bytes32 _id, string _name, string _ipfs, address _account)
external
onlyApprovedContract {
emit LogOperator(_message, keccak256(abi.encodePacked(_message)), _id, _name, _ipfs, _account, tx.origin);
}
function consensus(string _message, bytes32 _executionID, bytes32 _votesID, uint _votes, uint _tokens, uint _quorum)
external
onlyApprovedContract {
emit LogConsensus(_message, keccak256(abi.encodePacked(_message)), _executionID, _votesID, _votes, _tokens, _quorum, tx.origin);
}
event LogEvent(string message, bytes32 indexed messageID, address indexed origin);
event LogTransaction(string message, bytes32 indexed messageID, address indexed from, address indexed to, uint amount, address token, address origin); //amount and token will be empty on some events
event LogAddress(string message, bytes32 indexed messageID, address indexed account, address indexed origin);
event LogContractChange(string message, bytes32 indexed messageID, address indexed account, string name, address indexed origin);
event LogAsset(string message, bytes32 indexed messageID, string uri, bytes32 indexed assetID, address asset, address manager, address indexed origin);
event LogEscrow(string message, bytes32 indexed messageID, address asset, bytes32 escrowID, address indexed manager, uint amount, address indexed origin);
event LogOrder(string message, bytes32 indexed messageID, bytes32 indexed orderID, uint amount, uint price, address indexed origin);
event LogExchange(string message, bytes32 indexed messageID, bytes32 orderID, address indexed asset, address account, address indexed origin);
event LogOperator(string message, bytes32 indexed messageID, bytes32 id, string name, string ipfs, address indexed account, address indexed origin);
event LogConsensus(string message, bytes32 indexed messageID, bytes32 executionID, bytes32 votesID, uint votes, uint tokens, uint quorum, address indexed origin);
modifier onlyApprovedContract() {
require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
_;
}
}
interface KyberInterface {
function getExpectedRate(address src, address dest, uint srcQty) external view returns (uint expectedRate, uint slippageRate);
function trade(address src, uint srcAmount, address dest, address destAddress, uint maxDestAmount,uint minConversionRate, address walletId) external payable returns(uint);
}
interface MinterInterface {
function cloneToken(string _uri, address _erc20Address) external returns (address asset);
function mintAssetTokens(address _assetAddress, address _receiver, uint256 _amount) external returns (bool);
function changeTokenController(address _assetAddress, address _newController) external returns (bool);
}
interface CrowdsaleGeneratorETH_ERC20 {
function balanceOf(address _who) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _value) external returns (bool);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract CrowdsaleGeneratorETH {
using SafeMath for uint256;
DBInterface public database;
Events public events;
KyberInterface private kyber;
MinterInterface private minter;
constructor(address _database, address _events, address _kyber)
public{
database = DBInterface(_database);
events = Events(_events);
kyber = KyberInterface(_kyber);
minter = MinterInterface(database.addressStorage(keccak256(abi.encodePacked("contract", "Minter"))));
}
function() public payable {
}
function createAssetOrderETH(string _assetURI, string _ipfs, uint _fundingLength, uint _amountToRaise, uint _assetManagerPerc, uint _escrowAndFee, address _paymentToken)
external
payable {
if(_paymentToken == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
require(msg.value == _escrowAndFee);
} else {
require(msg.value == 0);
CrowdsaleGeneratorETH_ERC20(_paymentToken).transferFrom(msg.sender, address(this), _escrowAndFee);
}
require(_amountToRaise >= 100, "Crowdsale goal is too small");
require((_assetManagerPerc + database.uintStorage(keccak256(abi.encodePacked("platform.percentage")))) < 100, "Manager percent need to be less than 100");
require(!database.boolStorage(keccak256(abi.encodePacked("asset.uri", _assetURI))), "Asset URI is not unique"); //Check that asset URI is unique
uint escrow = processListingFee(_paymentToken, _escrowAndFee);
address assetAddress = minter.cloneToken(_assetURI, address(0));
require(setCrowdsaleValues(assetAddress, _fundingLength, _amountToRaise));
require(setAssetValues(assetAddress, _assetURI, _ipfs, msg.sender, _assetManagerPerc, _amountToRaise));
if(escrow > 0) {
require(lockEscrowETH(msg.sender, assetAddress, _paymentToken, escrow));
}
events.asset('Asset funding started', _assetURI, assetAddress, msg.sender);
events.asset('New asset ipfs', _ipfs, assetAddress, msg.sender);
}
function updateIPFS(address _assetAddress, string _ipfs)
external {
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))));
database.setString(keccak256(abi.encodePacked("asset.ipfs", _assetAddress)), _ipfs);
events.asset('New asset ipfs', _ipfs, _assetAddress, msg.sender);
}
function destroy()
onlyOwner
external {
events.transaction('CrowdsaleGeneratorETH destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
function setCrowdsaleValues(address _assetAddress, uint _fundingLength, uint _amountToRaise)
private
returns (bool){
database.setUint(keccak256(abi.encodePacked("crowdsale.start", _assetAddress)), now);
database.setUint(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress)), now.add(_fundingLength));
database.setUint(keccak256(abi.encodePacked("crowdsale.goal", _assetAddress)), _amountToRaise);
database.setUint(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)), _amountToRaise.mul(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee"))))).div(100));
return true;
}
function setAssetValues(address _assetAddress, string _assetURI, string _ipfs, address _assetManager, uint _assetManagerPerc, uint _amountToRaise)
private
returns (bool){
uint totalTokens = _amountToRaise.mul(100).div(uint(100).sub(_assetManagerPerc).sub(database.uintStorage(keccak256(abi.encodePacked("platform.percentage")))));
database.setUint(keccak256(abi.encodePacked("asset.managerTokens", _assetAddress)), totalTokens.getFractionalAmount(_assetManagerPerc));
database.setUint(keccak256(abi.encodePacked("asset.platformTokens", _assetAddress)), totalTokens.getFractionalAmount(database.uintStorage(keccak256(abi.encodePacked("platform.percentage")))));
database.setAddress(keccak256(abi.encodePacked("asset.manager", _assetAddress)), _assetManager);
database.setString(keccak256(abi.encodePacked("asset.ipfs", _assetAddress)), _ipfs);
database.setBool(keccak256(abi.encodePacked("asset.uri", _assetURI)), true); //Set to ensure a unique asset URI
return true;
}
function processListingFee(address _paymentTokenAddress, uint _fromAmount)
private
returns (uint) { // returns left amount
uint listingFee = database.uintStorage(keccak256(abi.encodePacked("platform.listingFee")));
address listingFeeTokenAddress = database.addressStorage(keccak256(abi.encodePacked("platform.listingFeeToken")));
address platformFundsWallet = database.addressStorage(keccak256(abi.encodePacked("platform.wallet.funds")));
uint usedAmount;
uint balanceBefore;
uint listingFeePaid;
uint expectedRate;
uint estimation;
CrowdsaleGeneratorETH_ERC20 paymentToken;
if (_paymentTokenAddress != listingFeeTokenAddress) {
(expectedRate,) = kyber.getExpectedRate(listingFeeTokenAddress, _paymentTokenAddress, listingFee);
estimation = expectedRate * listingFee / 0.8 ether; // giving slippage rate of 0.8
if(_paymentTokenAddress == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
balanceBefore = address(this).balance;
listingFeePaid = kyber.trade.value(estimation)(_paymentTokenAddress, estimation, listingFeeTokenAddress, platformFundsWallet, listingFee, 0, 0);
usedAmount = balanceBefore - address(this).balance; // used eth by kyber for swapping with token
} else {
paymentToken = CrowdsaleGeneratorETH_ERC20(_paymentTokenAddress);
balanceBefore = paymentToken.balanceOf(address(this));
require(paymentToken.approve(address(kyber), estimation));
listingFeePaid = kyber.trade(_paymentTokenAddress, estimation, listingFeeTokenAddress, platformFundsWallet, listingFee, 0, 0); //Currently no minimum rate is set, so watch out for slippage!
paymentToken.approve(address(kyber), 0);
usedAmount = balanceBefore - paymentToken.balanceOf(address(this));
}
} else {
paymentToken = CrowdsaleGeneratorETH_ERC20(_paymentTokenAddress);
require(paymentToken.transfer(platformFundsWallet, listingFee), "Listing fee not paid");
usedAmount = listingFee;
listingFeePaid = listingFee;
}
require(_fromAmount >= usedAmount && listingFeePaid >= listingFee, "Listing fee not paid");
return _fromAmount - usedAmount;
}
function lockEscrowETH(address _assetManager, address _assetAddress, address _paymentTokenAddress, uint _amount)
private
returns (bool) {
uint amount;
bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetAddress, _assetManager));
address platformTokenAddress = database.addressStorage(keccak256(abi.encodePacked("platform.token")));
if(_paymentTokenAddress != platformTokenAddress){
if(_paymentTokenAddress == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
amount = kyber.trade.value(_amount)(_paymentTokenAddress, _amount, platformTokenAddress, address(this), 2**255, 0, 0); //Currently no minimum rate is set, so watch out for slippage!
} else {
CrowdsaleGeneratorETH_ERC20 paymentToken = CrowdsaleGeneratorETH_ERC20(_paymentTokenAddress);
require(paymentToken.approve(address(kyber), _amount));
amount = kyber.trade(_paymentTokenAddress, _amount, platformTokenAddress, address(this), 2**255, 0, 0); //Currently no minimum rate is set, so watch out for slippage!
}
} else {
amount = _amount;
}
require(CrowdsaleGeneratorETH_ERC20(platformTokenAddress).transfer(database.addressStorage(keccak256(abi.encodePacked("contract", "EscrowReserve"))), amount));
database.setUint(keccak256(abi.encodePacked("asset.escrow", assetManagerEscrowID)), amount);
events.escrow('Escrow locked', _assetAddress, assetManagerEscrowID, _assetManager, amount);
return true;
}
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))), "Not owner");
_;
}
}
| 275,234 | 11,491 |
0175d4c649d44594e6fa373e24bb17559e96dd8e49c362ce256b3f651e9a1b85
| 26,230 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/46/464c0Abb33536cce871c63484c28e2630A889232_GitHubMarket.sol
| 3,577 | 13,693 |
// Sources flattened with hardhat v2.6.6 https://hardhat.org
// File @openzeppelin/contracts-upgradeable/proxy/utils/[emailprotected]
// SPDX-License-Identifier: MPL-2.0
pragma solidity 0.8.4;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
// File @openzeppelin/contracts-upgradeable/utils/[emailprotected]
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// File @openzeppelin/contracts-upgradeable/security/[emailprotected]
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal initializer {
__Context_init_unchained();
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal initializer {
_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());
}
uint256[49] private __gap;
}
// File @openzeppelin/contracts-upgradeable/access/[emailprotected]
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// File @openzeppelin/contracts-upgradeable/utils/[emailprotected]
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// File @openzeppelin/contracts-upgradeable/utils/introspection/[emailprotected]
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts-upgradeable/utils/introspection/[emailprotected]
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal initializer {
__ERC165_init_unchained();
}
function __ERC165_init_unchained() internal initializer {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
// File @openzeppelin/contracts-upgradeable/access/[emailprotected]
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
// File @devprotocol/protocol-v2/contracts/interface/[emailprotected]
interface IAddressRegistry {
function setRegistry(string memory _key, address _addr) external;
function registries(string memory _key) external view returns (address);
}
// File @devprotocol/protocol-v2/contracts/interface/[emailprotected]
interface IMarketBehavior {
function authenticate(address _prop,
string[] memory _args,
address account) external returns (bool);
function setAssociatedMarket(address _market) external;
function associatedMarket() external view returns (address);
function name() external view returns (string memory);
function schema() external view returns (string memory);
function getId(address _metrics) external view returns (string memory);
function getMetrics(string memory _id) external view returns (address);
}
// File @devprotocol/protocol-v2/contracts/interface/[emailprotected]
interface IMarket {
function authenticate(address _prop, string[] memory _args)
external
returns (bool);
function authenticateFromPropertyFactory(address _prop,
address _author,
string[] memory _args) external returns (bool);
function authenticatedCallback(address _property, bytes32 _idHash)
external
returns (address);
function deauthenticate(address _metrics) external;
function name() external view returns (string memory);
function schema() external view returns (string memory);
function behavior() external view returns (address);
function issuedMetrics() external view returns (uint256);
function enabled() external view returns (bool);
function votingEndTimestamp() external view returns (uint256);
function getAuthenticatedProperties()
external
view
returns (address[] memory);
function toEnable() external;
}
// File contracts/GitHubMarket.sol
contract GitHubMarket is
IMarketBehavior,
PausableUpgradeable,
AccessControlUpgradeable
{
address public override associatedMarket;
address public associatedMarketSetter;
mapping(address => string) private repositories;
mapping(bytes32 => address) private metrics;
mapping(bytes32 => address) private properties;
mapping(bytes32 => bool) private pendingAuthentication;
// ROLE
bytes32 public constant KHAOS_ROLE = keccak256("KHAOS_ROLE");
// event
event Registered(address _metrics, string _repository);
event Authenticated(string _repository, uint256 _status, string message);
event Query(string githubRepository,
string publicSignature,
address account);
function initialize() external initializer {
__AccessControl_init();
__Pausable_init();
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setRoleAdmin(KHAOS_ROLE, DEFAULT_ADMIN_ROLE);
_setupRole(KHAOS_ROLE, _msgSender());
}
function authenticate(address _prop,
string[] memory _args,
address account) external override whenNotPaused returns (bool) {
require(msg.sender == associatedMarket, "invalid sender");
require(_args.length == 2, "args error");
string memory githubRepository = _args[0];
string memory publicSignature = _args[1];
bytes32 key = createKey(githubRepository);
emit Query(githubRepository, publicSignature, account);
properties[key] = _prop;
pendingAuthentication[key] = true;
return true;
}
function khaosCallback(string memory _githubRepository,
uint256 _status,
string memory _message) external whenNotPaused {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) ||
hasRole(KHAOS_ROLE, msg.sender),
"illegal access");
require(_status == 0, _message);
bytes32 key = createKey(_githubRepository);
require(pendingAuthentication[key], "not while pending");
emit Authenticated(_githubRepository, _status, _message);
register(key, _githubRepository, properties[key]);
}
function register(bytes32 _key,
string memory _repository,
address _property) private {
address _metrics = IMarket(associatedMarket).authenticatedCallback(_property,
_key);
repositories[_metrics] = _repository;
metrics[_key] = _metrics;
emit Registered(_metrics, _repository);
}
function createKey(string memory _repository)
private
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(_repository));
}
function getId(address _metrics)
external
view
override
returns (string memory)
{
return repositories[_metrics];
}
function getMetrics(string memory _repository)
external
view
override
returns (address)
{
return metrics[createKey(_repository)];
}
function addKhaosRole(address _khaos)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
_setupRole(KHAOS_ROLE, _khaos);
}
function deleteKhaosRole(address _khaos)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
revokeRole(KHAOS_ROLE, _khaos);
}
function setAssociatedMarket(address _associatedMarket) external override {
if(associatedMarket == address(0)) {
associatedMarket = _associatedMarket;
associatedMarketSetter = msg.sender;
return;
}
if (associatedMarketSetter == msg.sender) {
associatedMarket = _associatedMarket;
return;
}
revert("illegal access");
}
function name() external pure override returns (string memory) {
return "GitHub";
}
function schema() external pure override returns (string memory) {
return
// solhint-disable-next-line quotes
'["GitHub Repository (e.g, your/awesome-repos)", "Khaos Public Signature"]';
}
function pause() external onlyRole(DEFAULT_ADMIN_ROLE) whenNotPaused {
_pause();
}
function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) whenPaused {
_unpause();
}
}
| 43,736 | 11,492 |
afcbdf0d39ea45d5c9c54944d973a7690212c23497d9a14d55bc0a2a910618d7
| 28,031 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x840af39124887ead7938fc07810e5932ec74eea2.sol
| 5,652 | 23,301 |
pragma solidity ^0.4.24;
// File: Multiownable/contracts/Multiownable.sol
contract Multiownable {
// VARIABLES
uint256 public ownersGeneration;
uint256 public howManyOwnersDecide;
address[] public owners;
bytes32[] public allOperations;
address internal insideCallSender;
uint256 internal insideCallCount;
// Reverse lookup tables for owners and allOperations
mapping(address => uint) public ownersIndices; // Starts from 1
mapping(bytes32 => uint) public allOperationsIndicies;
// Owners voting mask per operations
mapping(bytes32 => uint256) public votesMaskByOperation;
mapping(bytes32 => uint256) public votesCountByOperation;
// EVENTS
event OwnershipTransferred(address[] previousOwners, uint howManyOwnersDecide, address[] newOwners, uint newHowManyOwnersDecide);
event OperationCreated(bytes32 operation, uint howMany, uint ownersCount, address proposer);
event OperationUpvoted(bytes32 operation, uint votes, uint howMany, uint ownersCount, address upvoter);
event OperationPerformed(bytes32 operation, uint howMany, uint ownersCount, address performer);
event OperationDownvoted(bytes32 operation, uint votes, uint ownersCount, address downvoter);
event OperationCancelled(bytes32 operation, address lastCanceller);
// ACCESSORS
function isOwner(address wallet) public constant returns(bool) {
return ownersIndices[wallet] > 0;
}
function ownersCount() public constant returns(uint) {
return owners.length;
}
function allOperationsCount() public constant returns(uint) {
return allOperations.length;
}
// MODIFIERS
modifier onlyAnyOwner {
if (checkHowManyOwners(1)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = 1;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlyManyOwners {
if (checkHowManyOwners(howManyOwnersDecide)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = howManyOwnersDecide;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlyAllOwners {
if (checkHowManyOwners(owners.length)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = owners.length;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlySomeOwners(uint howMany) {
require(howMany > 0, "onlySomeOwners: howMany argument is zero");
require(howMany <= owners.length, "onlySomeOwners: howMany argument exceeds the number of owners");
if (checkHowManyOwners(howMany)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = howMany;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
// CONSTRUCTOR
constructor() public {
owners.push(msg.sender);
ownersIndices[msg.sender] = 1;
howManyOwnersDecide = 1;
}
// INTERNAL METHODS
function checkHowManyOwners(uint howMany) internal returns(bool) {
if (insideCallSender == msg.sender) {
require(howMany <= insideCallCount, "checkHowManyOwners: nested owners modifier check require more owners");
return true;
}
uint ownerIndex = ownersIndices[msg.sender] - 1;
require(ownerIndex < owners.length, "checkHowManyOwners: msg.sender is not an owner");
bytes32 operation = keccak256(msg.data, ownersGeneration);
require((votesMaskByOperation[operation] & (2 ** ownerIndex)) == 0, "checkHowManyOwners: owner already voted for the operation");
votesMaskByOperation[operation] |= (2 ** ownerIndex);
uint operationVotesCount = votesCountByOperation[operation] + 1;
votesCountByOperation[operation] = operationVotesCount;
if (operationVotesCount == 1) {
allOperationsIndicies[operation] = allOperations.length;
allOperations.push(operation);
emit OperationCreated(operation, howMany, owners.length, msg.sender);
}
emit OperationUpvoted(operation, operationVotesCount, howMany, owners.length, msg.sender);
// If enough owners confirmed the same operation
if (votesCountByOperation[operation] == howMany) {
deleteOperation(operation);
emit OperationPerformed(operation, howMany, owners.length, msg.sender);
return true;
}
return false;
}
function deleteOperation(bytes32 operation) internal {
uint index = allOperationsIndicies[operation];
if (index < allOperations.length - 1) { // Not last
allOperations[index] = allOperations[allOperations.length - 1];
allOperationsIndicies[allOperations[index]] = index;
}
allOperations.length--;
delete votesMaskByOperation[operation];
delete votesCountByOperation[operation];
delete allOperationsIndicies[operation];
}
// PUBLIC METHODS
function cancelPending(bytes32 operation) public onlyAnyOwner {
uint ownerIndex = ownersIndices[msg.sender] - 1;
require((votesMaskByOperation[operation] & (2 ** ownerIndex)) != 0, "cancelPending: operation not found for this user");
votesMaskByOperation[operation] &= ~(2 ** ownerIndex);
uint operationVotesCount = votesCountByOperation[operation] - 1;
votesCountByOperation[operation] = operationVotesCount;
emit OperationDownvoted(operation, operationVotesCount, owners.length, msg.sender);
if (operationVotesCount == 0) {
deleteOperation(operation);
emit OperationCancelled(operation, msg.sender);
}
}
function transferOwnership(address[] newOwners) public {
transferOwnershipWithHowMany(newOwners, newOwners.length);
}
function transferOwnershipWithHowMany(address[] newOwners, uint256 newHowManyOwnersDecide) public onlyManyOwners {
require(newOwners.length > 0, "transferOwnershipWithHowMany: owners array is empty");
require(newOwners.length <= 256, "transferOwnershipWithHowMany: owners count is greater then 256");
require(newHowManyOwnersDecide > 0, "transferOwnershipWithHowMany: newHowManyOwnersDecide equal to 0");
require(newHowManyOwnersDecide <= newOwners.length, "transferOwnershipWithHowMany: newHowManyOwnersDecide exceeds the number of owners");
// Reset owners reverse lookup table
for (uint j = 0; j < owners.length; j++) {
delete ownersIndices[owners[j]];
}
for (uint i = 0; i < newOwners.length; i++) {
require(newOwners[i] != address(0), "transferOwnershipWithHowMany: owners array contains zero");
require(ownersIndices[newOwners[i]] == 0, "transferOwnershipWithHowMany: owners array contains duplicates");
ownersIndices[newOwners[i]] = i + 1;
}
emit OwnershipTransferred(owners, howManyOwnersDecide, newOwners, newHowManyOwnersDecide);
owners = newOwners;
howManyOwnersDecide = newHowManyOwnersDecide;
allOperations.length = 0;
ownersGeneration++;
}
}
// File: 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: 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: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: contracts/BadERC20Aware.sol
library BadERC20Aware {
using SafeMath for uint;
function isContract(address addr) internal view returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
result := gt(extcodesize(addr), 0)
}
}
function handleReturnBool() internal pure returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
switch returndatasize()
case 0 { // not a std erc20
result := 1
}
case 32 { // std erc20
returndatacopy(0, 0, 32)
result := mload(0)
}
default { // anything else, should revert for safety
revert(0, 0)
}
}
}
function asmTransfer(ERC20 _token, address _to, uint256 _value) internal returns(bool) {
require(isContract(_token));
// solium-disable-next-line security/no-low-level-calls
require(address(_token).call(bytes4(keccak256("transfer(address,uint256)")), _to, _value));
return handleReturnBool();
}
function safeTransfer(ERC20 _token, address _to, uint256 _value) internal {
require(asmTransfer(_token, _to, _value));
}
}
// File: contracts/TokenSwap.sol
contract TokenSwap is Ownable, Multiownable {
// LIBRARIES
using BadERC20Aware for ERC20;
using SafeMath for uint256;
// TYPES
enum Status {AddParties, WaitingDeposits, SwapConfirmed, SwapCanceled}
struct SwapOffer {
address participant;
ERC20 token;
uint256 tokensForSwap;
uint256 withdrawnTokensForSwap;
uint256 tokensFee;
uint256 withdrawnFee;
uint256 tokensTotal;
uint256 withdrawnTokensTotal;
}
struct LockupStage {
uint256 secondsSinceLockupStart;
uint8 unlockedTokensPercentage;
}
// VARIABLES
Status public status = Status.AddParties;
uint256 internal startLockupAt;
LockupStage[] internal lockupStages;
address[] internal participants;
mapping(address => bool) internal isParticipant;
mapping(address => address) internal tokenByParticipant;
mapping(address => SwapOffer) internal offerByToken;
// EVENTS
event AddLockupStage(uint256 secondsSinceLockupStart, uint8 unlockedTokensPercentage);
event StatusUpdate(Status oldStatus, Status newStatus);
event AddParty(address participant, ERC20 token, uint256 amount);
event RemoveParty(address participant);
event ConfirmParties();
event CancelSwap();
event ConfirmSwap();
event StartLockup(uint256 startLockupAt);
event Withdraw(address participant, ERC20 token, uint256 amount);
event WithdrawFee(ERC20 token, uint256 amount);
event Reclaim(address participant, ERC20 token, uint256 amount);
// MODIFIERS
modifier onlyParticipant {
require(isParticipant[msg.sender] == true,
"Only swap participants allowed to call the method");
_;
}
modifier canAddParty {
require(status == Status.AddParties, "Unable to add new parties in the current status");
_;
}
modifier canRemoveParty {
require(status == Status.AddParties, "Unable to remove parties in the current status");
_;
}
modifier canConfirmParties {
require(status == Status.AddParties,
"Unable to confirm parties in the current status");
require(participants.length > 1, "Need at least two participants");
_;
}
modifier canCancelSwap {
require(status == Status.WaitingDeposits,
"Unable to cancel swap in the current status");
_;
}
modifier canConfirmSwap {
require(status == Status.WaitingDeposits, "Unable to confirm in the current status");
require(_haveEveryoneDeposited(),
"Unable to confirm swap before all parties have deposited tokens");
_;
}
modifier canWithdraw {
require(status == Status.SwapConfirmed, "Unable to withdraw tokens in the current status");
require(startLockupAt != 0, "Lockup has not been started");
_;
}
modifier canWithdrawFee {
require(status == Status.SwapConfirmed, "Unable to withdraw fee in the current status");
require(startLockupAt != 0, "Lockup has not been started");
_;
}
modifier canReclaim {
require(status == Status.SwapConfirmed || status == Status.SwapCanceled,
"Unable to reclaim in the current status");
_;
}
// CONSTRUCTOR
constructor() public {
_initializeLockupStages();
_validateLockupStages();
}
// EXTERNAL METHODS
function addParty(address _participant,
ERC20 _token,
uint256 _tokensForSwap,
uint256 _tokensFee,
uint256 _tokensTotal)
external
onlyOwner
canAddParty
{
require(_participant != address(0), "_participant is invalid address");
require(_token != address(0), "_token is invalid address");
require(_tokensForSwap > 0, "_tokensForSwap must be positive");
require(_tokensFee > 0, "_tokensFee must be positive");
require(_tokensTotal == _tokensForSwap.add(_tokensFee), "token amounts inconsistency");
require(isParticipant[_participant] == false,
"Unable to add the same party multiple times");
isParticipant[_participant] = true;
SwapOffer memory offer = SwapOffer({
participant: _participant,
token: _token,
tokensForSwap: _tokensForSwap,
withdrawnTokensForSwap: 0,
tokensFee: _tokensFee,
withdrawnFee: 0,
tokensTotal: _tokensTotal,
withdrawnTokensTotal: 0
});
participants.push(offer.participant);
offerByToken[offer.token] = offer;
tokenByParticipant[offer.participant] = offer.token;
emit AddParty(offer.participant, offer.token, offer.tokensTotal);
}
function removeParty(uint256 _participantIndex) external onlyOwner canRemoveParty {
require(_participantIndex < participants.length, "Participant does not exist");
address participant = participants[_participantIndex];
address token = tokenByParticipant[participant];
delete isParticipant[participant];
participants[_participantIndex] = participants[participants.length - 1];
participants.length--;
delete offerByToken[token];
delete tokenByParticipant[participant];
emit RemoveParty(participant);
}
function confirmParties() external onlyOwner canConfirmParties {
address[] memory newOwners = new address[](participants.length + 1);
for (uint256 i = 0; i < participants.length; i++) {
newOwners[i] = participants[i];
}
newOwners[newOwners.length - 1] = owner;
transferOwnershipWithHowMany(newOwners, newOwners.length - 1);
_changeStatus(Status.WaitingDeposits);
emit ConfirmParties();
}
function confirmSwap() external canConfirmSwap onlyManyOwners {
emit ConfirmSwap();
_changeStatus(Status.SwapConfirmed);
_startLockup();
}
function cancelSwap() external canCancelSwap onlyManyOwners {
emit CancelSwap();
_changeStatus(Status.SwapCanceled);
}
function withdraw() external onlyParticipant canWithdraw {
for (uint i = 0; i < participants.length; i++) {
address token = tokenByParticipant[participants[i]];
SwapOffer storage offer = offerByToken[token];
if (offer.participant == msg.sender) {
continue;
}
uint256 tokenReceivers = participants.length - 1;
uint256 tokensAmount = _withdrawableAmount(offer).div(tokenReceivers);
offer.token.safeTransfer(msg.sender, tokensAmount);
emit Withdraw(msg.sender, offer.token, tokensAmount);
offer.withdrawnTokensForSwap = offer.withdrawnTokensForSwap.add(tokensAmount);
offer.withdrawnTokensTotal = offer.withdrawnTokensTotal.add(tokensAmount);
}
}
function withdrawFee() external onlyOwner canWithdrawFee {
for (uint i = 0; i < participants.length; i++) {
address token = tokenByParticipant[participants[i]];
SwapOffer storage offer = offerByToken[token];
uint256 tokensAmount = _withdrawableFee(offer);
offer.token.safeTransfer(msg.sender, tokensAmount);
emit WithdrawFee(offer.token, tokensAmount);
offer.withdrawnFee = offer.withdrawnFee.add(tokensAmount);
offer.withdrawnTokensTotal = offer.withdrawnTokensTotal.add(tokensAmount);
}
}
function reclaim() external onlyParticipant canReclaim {
address token = tokenByParticipant[msg.sender];
SwapOffer storage offer = offerByToken[token];
uint256 currentBalance = offer.token.balanceOf(address(this));
uint256 availableForReclaim = currentBalance
.sub(offer.tokensTotal.sub(offer.withdrawnTokensTotal));
if (status == Status.SwapCanceled) {
availableForReclaim = currentBalance;
}
if (availableForReclaim > 0) {
offer.token.safeTransfer(offer.participant, availableForReclaim);
}
emit Reclaim(offer.participant, offer.token, availableForReclaim);
}
// INTERNAL METHODS
function _initializeLockupStages() internal {
_addLockupStage(LockupStage(0, 10));
_addLockupStage(LockupStage(90 days, 32));
_addLockupStage(LockupStage(180 days, 55));
_addLockupStage(LockupStage(270 days, 77));
_addLockupStage(LockupStage(360 days, 100));
}
function _addLockupStage(LockupStage _stage) internal {
emit AddLockupStage(_stage.secondsSinceLockupStart, _stage.unlockedTokensPercentage);
lockupStages.push(_stage);
}
function _validateLockupStages() internal view {
for (uint i = 0; i < lockupStages.length; i++) {
LockupStage memory stage = lockupStages[i];
require(stage.unlockedTokensPercentage >= 0,
"LockupStage.unlockedTokensPercentage must not be negative");
require(stage.unlockedTokensPercentage <= 100,
"LockupStage.unlockedTokensPercentage must not be greater than 100");
if (i == 0) {
continue;
}
LockupStage memory previousStage = lockupStages[i - 1];
require(stage.secondsSinceLockupStart > previousStage.secondsSinceLockupStart,
"LockupStage.secondsSinceLockupStart must increase monotonically");
require(stage.unlockedTokensPercentage > previousStage.unlockedTokensPercentage,
"LockupStage.unlockedTokensPercentage must increase monotonically");
}
require(lockupStages[0].secondsSinceLockupStart == 0,
"The first lockup stage must start immediately");
require(lockupStages[lockupStages.length - 1].unlockedTokensPercentage == 100,
"The last lockup stage must unlock 100% of tokens");
}
function _changeStatus(Status _newStatus) internal {
emit StatusUpdate(status, _newStatus);
status = _newStatus;
}
function _haveEveryoneDeposited() internal view returns(bool) {
for (uint i = 0; i < participants.length; i++) {
address token = tokenByParticipant[participants[i]];
SwapOffer memory offer = offerByToken[token];
if (offer.token.balanceOf(address(this)) < offer.tokensTotal) {
return false;
}
}
return true;
}
function _startLockup() internal {
startLockupAt = now;
emit StartLockup(startLockupAt);
}
function _withdrawableAmount(SwapOffer _offer) internal view returns(uint256) {
return _unlockedAmount(_offer.tokensForSwap).sub(_offer.withdrawnTokensForSwap);
}
function _withdrawableFee(SwapOffer _offer) internal view returns(uint256) {
return _unlockedAmount(_offer.tokensFee).sub(_offer.withdrawnFee);
}
function _unlockedAmount(uint256 totalAmount) internal view returns(uint256) {
return totalAmount.mul(_getUnlockedTokensPercentage()).div(100);
}
function _getUnlockedTokensPercentage() internal view returns(uint256) {
for (uint256 i = lockupStages.length; i > 0; i--) {
LockupStage storage stage = lockupStages[i - 1];
uint256 stageBecomesActiveAt = startLockupAt.add(stage.secondsSinceLockupStart);
if (now < stageBecomesActiveAt) {
continue;
}
return stage.unlockedTokensPercentage;
}
}
}
| 177,281 | 11,493 |
51d34fc684b28f269bffa5a3e49a53bee61006f81e4201f2bfa7350382720439
| 12,162 |
.sol
|
Solidity
| false |
238301548
|
ImmutableSoft/ImmutableEcosystem
|
b69792be8586ec883c3c8d6df18465705fe29c5d
|
contracts/StringCommon.sol
| 2,540 | 9,431 |
pragma solidity >=0.7.6;
// SPDX-License-Identifier: GPL-3.0-or-later
// OpenZepellin upgradable contracts
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
/// @title Immutable String - common constants and string routines
/// @author Sean Lawless for ImmutableSoft Inc.
/// @dev StringCommon is string related general/pure functions
contract StringCommon is Initializable, OwnableUpgradeable
{
// Entity Status
// Type is first 32 bits (bits 0 through 31)
uint256 public constant Unknown = 0;
uint256 public constant Creator = 1;
uint256 public constant Distributor = 2;
uint256 public constant EndUser = 3;
// Flags begin at bit 32 and go until bit 63
uint256 public constant Nonprofit = (1 << 32);
uint256 public constant Automatic = (1 << 33);
uint256 public constant CustomToken = (1 << 34);
// Country of origin
uint256 public constant CoutryCodeOffset =64;
uint256 public constant CoutryCodeMask = (0xFFFF << CoutryCodeOffset);
// Product Details
// Category is first 32 bits (bits 0 through 31)
uint256 public constant Tools = 0;
uint256 public constant System = 1;
uint256 public constant Platform = 2;
uint256 public constant Education = 3;
uint256 public constant Entertainment = 4;
uint256 public constant Communications = 5;
uint256 public constant Professional = 6;
uint256 public constant Manufacturing = 7;
uint256 public constant Business = 8;
// Room here for expansion
// Flags begin at bit 32 and go until bit 63
uint256 public constant Hazard = (1 << 32);
uint256 public constant Adult = (1 << 33);
uint256 public constant Restricted = (1 << 34);
// Distribution restricted by export laws of orgin country?
uint256 public constant USCryptoExport = (1 << 35);
uint256 public constant EUCryptoExport = (1 << 36);
// Languages begin at bit 64 and go until bit 127
// Ordered by percentage of native speakers
// https://en.wikipedia.org/wiki/List_of_languages_by_number_of_native_speakers
uint256 public constant Mandarin = (1 << 64);
uint256 public constant Spanish = (1 << 65);
uint256 public constant English = (1 << 66);
uint256 public constant Hindi = (1 << 67);
uint256 public constant Bengali = (1 << 68);
uint256 public constant Portuguese = (1 << 69);
uint256 public constant Russian = (1 << 70);
uint256 public constant Japanese = (1 << 71);
uint256 public constant Punjabi = (1 << 71);
uint256 public constant Marathi = (1 << 72);
uint256 public constant Teluga = (1 << 73);
uint256 public constant Wu = (1 << 74);
uint256 public constant Turkish = (1 << 75);
uint256 public constant Korean = (1 << 76);
uint256 public constant French = (1 << 77);
uint256 public constant German = (1 << 78);
uint256 public constant Vietnamese = (1 << 79);
// Room here for 47 additional languages (bit 127)
// Bits 128 - 255 Room here for expansion
// Up to 128 additional languages for example
// Product Release Version
// Version is first four 16 bit values (first 64 bits)
// Version 0.0.0.0
// Language bits from above form bits 64 to 127
// The Platform Type begins at bit 128 and goes until bit 159
uint256 public constant Windows_x86 = (1 << 128);
uint256 public constant Windows_amd64 = (1 << 129);
uint256 public constant Windows_aarch64 =(1 << 130);
uint256 public constant Linux_x86 = (1 << 131);
uint256 public constant Linux_amd64 = (1 << 132);
uint256 public constant Linux_aarch64 = (1 << 133);
uint256 public constant Android_aarch64 =(1 << 134);
uint256 public constant iPhone_arm64 = (1 << 135);
uint256 public constant BIOS_x86 = (1 << 136);
uint256 public constant BIOS_amd64 = (1 << 137);
uint256 public constant BIOS_aarch32 = (1 << 138);
uint256 public constant BIOS_aarch64 = (1 << 139);
uint256 public constant BIOS_arm64 = (1 << 140);
uint256 public constant Mac_amd64 = (1 << 141);
uint256 public constant Mac_arm64 = (1 << 142);
// Room here for expansion
// End with general types
uint256 public constant SourceCode = (1 << 156);
uint256 public constant Agnostic = (1 << 157);
uint256 public constant NotApplicable = (1 << 158);
uint256 public constant Other = (1 << 159);
// Room for expansion up to value (255 << 152) (last byte of type)
// Bits 160 through 256 are available for expansion
// Product License Activation Flags
// Flags begin at bit 160 and go until bit 191
uint256 public constant ExpirationFlag = (1 << 160); // Activation expiration
uint256 public constant LimitationFlag = (1 << 161); // Version/language limitations
// Cannot be used with feature
uint256 public constant NoResaleFlag = (1 << 162); // Disallow resale after purchase
// Per EU "first sale" law, cannot
// be set if expiration NOT set
uint256 public constant FeatureFlag = (1 << 163); // Specific application feature
// ie. Value is feature specific
// CANNOT be used with Limitation
// flag
uint256 public constant LimitedOffersFlag = (1 << 164); // Limited number of offers
// UniqueId is used for number
// Offer flag only, not used in
// activate token id
uint256 public constant BulkOffersFlag = (1 << 165); // Limited number of offers
// UniqueId is used for number
// Offer flag only, not used in
// activate token id. Cannot be
// used with LimitedOffersFlag
uint256 public constant RicardianReqFlag = (1 << 166); // Ricardian client token
// ownership required before
// transfer or activation is allowed
// Offset and mask of entity and product identifiers
uint256 public constant EntityIdOffset = 224;
uint256 public constant EntityIdMask = (0xFFFFFFFF << EntityIdOffset);
uint256 public constant ProductIdOffset = 192;
uint256 public constant ProductIdMask = (0xFFFFFFFF << ProductIdOffset);
// CreatorToken only: Release id 32 bits
uint256 public constant ReleaseIdOffset = 160;
uint256 public constant ReleaseIdMask = (0xFFFFFFFF << ReleaseIdOffset);
// ActivateToken only: 16 bits to enforce unique token
uint256 public constant UniqueIdOffset = 176;
uint256 public constant UniqueIdMask = (0xFFFF << UniqueIdOffset);
// Flags allow different activation types and Value layout
uint256 public constant FlagsOffset = 160;
uint256 public constant FlagsMask = (0xFFFF << FlagsOffset);
// Expiration is common, last before common 128 bit Value
uint256 public constant ExpirationOffset = 128;
uint256 public constant ExpirationMask = (0xFFFFFFFF <<
ExpirationOffset);
// If limitation flag set, the Value is entirely utilized
// The value is the 128 LSBs
// 32 bits if limitations flag set (96 bits version/language)
// All 128 bits if limitations flag not set
//
uint256 public constant ValueOffset = 0;
uint256 public constant ValueMask = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
// Error strings
string public constant EntityIsZero = "EntityID zero";
string public constant OfferNotFound = "Offer not found";
string public constant EntityNotValidated = "Entity not validated";
string public constant ProductNotFound = "Product not found";
string public constant TokenEntityNoMatch = "Token entity does not match";
string public constant TokenProductNoMatch = "Token product id does not match";
string public constant TokenNotUnique = "TokenId is NOT unique";
/// @notice Initialize the StringCommon smart contract
/// Called during first deployment only (not on upgrade) as
/// this is an OpenZepellin upgradable contract
function initialize() public initializer
{
__Ownable_init();
}
/// @notice Compare strings and return true if equal.
/// Case sensitive.
/// @param _a The string to be compared
/// @param _b The string to compare
/// @return true if strings are equal, otherwise false
function stringsEqual(string memory _a, string memory _b)
public pure virtual returns (bool)
{
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
// Return false if length mismatch
if (a.length != b.length)
return false;
// Loop and return false if any character does not match
for (uint i = 0; i < a.length; i ++)
if (a[i] != b[i])
return false;
// Otherwise strings match so return true
return true;
}
}
| 227,611 | 11,494 |
c7cb30e8bf8974ad369eff80fe95cb643dd4696031e1506983d176454cc19a89
| 20,062 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/59/59ED14ECed525586e10B304A6b790f04b8EAE983_Vault.sol
| 5,685 | 19,093 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library 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;
}
}
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 IMansionsHelper {
function getClaimFee (address sender) external view returns (uint256);
function newTax () external view returns (uint256);
function claimUtility(uint64[] calldata _nodes, address whereTo, uint256 neededAmount, address excessAmountReceiver, address nodesOwner) external;
}
interface IMansionManager {
function getAddressRewards(address account) external view returns (uint);
function getUserMultiplier(address from) external view returns (uint256);
}
interface ITaxManager {
function execute(uint256 remainingRewards, address receiver) external;
}
contract Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
address public TRUST_V3 = 0x82fdACD535F6EEa710d1ab67746e9e68366Dce8f;
bool public paused;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
mapping(address => mapping (uint256 => bool)) public payoutClaimed;
mapping(address => mapping (uint256 => bool)) public stakedDuringCycle;
mapping(address => bool) public blacklist;
mapping(address => bool) public migrated;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 50000;
uint256[] public unstakeFees = [750000, 500000, 400000, 300000, 200000, 100000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [500000, 500000];
uint256[] public unstakeDistribution = [500000, 300000, 100000, 100000];
uint256 public precision = 1000000;
IMansionsHelper public MANSIONSHEPLER = IMansionsHelper(0x19234452F1005D85FCEa70380AB75EbBF6259f48);
IMansionManager public MANSIONSMANAGER = IMansionManager(0xc4a25F823582d9ccf5cf8C8BF5338073e7a51676);
ITaxManager public TAXMANAGER;
event Staked(address indexed _from, uint256 amount);
event Migrated(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, address _MANSIONSHEPELR, address _TAXMANAGER, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
MANSIONSHEPLER = IMansionsHelper(_MANSIONSHEPELR);
TAXMANAGER = ITaxManager(_TAXMANAGER);
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[user][i] == true) continue;
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / precision;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / precision;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
if (stakedDuringCycle[user][cycle] == false) return 0;
return amountStaked[user][cycle].mul(precision) / totalStaked[cycle];
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
function getUnstakeFees(address user) public view returns (uint256) {
return unstakeFees[currentCycle() - stakers[user].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[user].stakeCycle];
}
function getStakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].stakeCycle;
}
function getLastClaimCycleOfUser(address user) public view returns (uint256) {
return stakers[user].lastClaimCycle;
}
function getUnstakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].unstakeCycle;
}
function getAmountStakedOfUser(address user) public view returns (uint256) {
return stakers[user].amount;
}
function getTotalRewardsOfUser(address user) public view returns (uint256) {
return stakers[user].totalRewards;
}
// PUBLIC FUNCTIONS
function migrate() external {
require(paused == false, "MIGRATE: Contract is paused");
require(blacklist[msg.sender] == false, "MIGRATE: You are blacklisted");
require(migrated[msg.sender] == false, "MIGRATE: You already migrated");
require(Vault(TRUST_V3).amountStaked(msg.sender, 2) > 0, "MIGRATE: You were not staking.");
require(Vault(TRUST_V3).stakedDuringCycle(msg.sender, 2) == true, "MIGRATE: You were not staking");
require(currentCycle() == 1, "MIGRATE: Migration period is over");
migrated[msg.sender] = true;
stakers[msg.sender] = Stake({
stakeCycle: 1,
lastClaimCycle: 1,
unstakeCycle: 0,
amount: Vault(TRUST_V3).amountStaked(msg.sender, 2),
totalRewards: 0
});
amountStaked[msg.sender][currentCycle()] = stakers[msg.sender].amount;
totalStaked[currentCycle()] += stakers[msg.sender].amount;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Migrated(msg.sender, stakers[msg.sender].amount);
}
function stake(uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function compoundAndStake(uint64[] memory userNodes, uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
uint256 availableRewards = MANSIONSMANAGER.getAddressRewards(msg.sender) + MANSIONSMANAGER.getAddressRewards(msg.sender) * MANSIONSMANAGER.getUserMultiplier(msg.sender) / 1000;
require(availableRewards >= amount, "STAKE: Not enough to compound");
MANSIONSHEPLER.claimUtility(userNodes, address(this), amount, address(TAXMANAGER), msg.sender);
TAXMANAGER.execute(availableRewards - amount, msg.sender);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[msg.sender].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[msg.sender][i] == false && stakedDuringCycle[msg.sender][i] == true) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / precision;
payoutClaimed[msg.sender][i] = true;
}
}
require(sum > 0, "CLAIM4: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
require(payoutClaimed[msg.sender][cycle] == false, "CLAIM4: Nothing to claim");
require(stakedDuringCycle[msg.sender][cycle] == true, "CLAIM6: You unstaked");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / precision;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = cycle;
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake(bool bypassClaimAll) external {
require(paused == false, "UNSTAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "UNSTAKE: You are blacklisted");
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (bypassClaimAll == false) {
if (getAllRewardsOf(msg.sender) > 0) {
claimAll();
}
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / precision;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].stakeCycle = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
stakedDuringCycle[msg.sender][currentCycle()] = false;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / precision);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / precision);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / precision);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function setPrecision(uint256 _precision) external onlyOwner {
precision = _precision;
}
function setPaused(bool _val) external onlyOwner {
paused = _val;
}
function setPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBlacklisted(address user, bool _val) external onlyOwner {
blacklist[user] = _val;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setTaxManager(address _TAXMANAGER) external onlyOwner {
TAXMANAGER = ITaxManager(_TAXMANAGER);
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake * 10**16;
maxStake = _maxStake * 10**16;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 92,496 | 11,495 |
19b3b7ff973ae10551942d0b0d70d44a49bbbf07f74df1815ede8f69d14829a0
| 37,049 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNAKxY2ttsLHy47ZYDaJ2uGDiKf2Rxz16P_FuckToken.sol
| 4,518 | 17,721 |
//SourceUnit: EggToken.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;
}
}
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;
}
}
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);
}
}
}
}
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 => 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 FuckToken is ERC20("Fuck", "FUCK"), Ownable {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @dev A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @dev A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @dev The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @dev The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @dev 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)");
/// @dev A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @dev An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @dev An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "EGG::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "EGG::delegateBySig: invalid nonce");
require(now <= expiry, "EGG::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, "EGG::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 EGGs (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, "EGG::_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;
}
}
| 305,826 | 11,496 |
3606c249f8df884c945386e30f6767a070bc2652a1bc06b9bf9a3bd00c003012
| 30,776 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/18/18ae1a33044b9b4ccc85dc44da8bb03b86f06600_XenProxy.sol
| 3,126 | 13,200 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
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 {}
}
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return 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
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library 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)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot)
internal
pure
returns (BooleanSlot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot)
internal
pure
returns (Bytes32Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot)
internal
pure
returns (Uint256Slot storage r)
{
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
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 {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT,
"ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT =
0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return 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;
}
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);
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation()
internal
view
virtual
override
returns (address impl)
{
return ERC1967Upgrade._getImplementation();
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_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();
}
}
contract XenProxy is TransparentUpgradeableProxy {
constructor(address _logic, bytes memory _x)
TransparentUpgradeableProxy(_logic, tx.origin, _x)
{}
function _beforeFallback() internal override {}
}
| 84,209 | 11,497 |
80310cfc54dc8d1863f782b8d6dadeac982d5d4446d561b9e97061fda417608a
| 18,365 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRX7nF35Go9ikTtnUryD9PUq3GpqKEuALH_Tron4Life.sol
| 4,828 | 17,545 |
//SourceUnit: tron4life.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Tron4Life is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 6 ; // 6% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 3; // 3% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 2; // 2% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 1; // 1% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 260; // 26% Daily Roi
uint256 public constant PLAN_TERM = 4 days; // 4 Days
uint256 public constant CONTRACT_LIMIT = 950; // 5% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "95% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 288,707 | 11,498 |
7388e3a0cfb18d96ddeb039c9c27744c94ed6b281ee3d4c34d676a60ef2b4b3b
| 24,731 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb29adf6cb1af1d66507e7077dc2df30f7138fde5.sol
| 4,919 | 17,863 |
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
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;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract MultiOwnable {
address public root;
mapping (address => bool) public owners;
constructor() public {
root = msg.sender;
owners[root] = true;
}
modifier onlyOwner() {
require(owners[msg.sender]);
_;
}
modifier onlyRoot() {
require(msg.sender == root);
_;
}
function newOwner(address owner) onlyRoot public returns (bool) {
require(owner != address(0));
owners[owner] = true;
return true;
}
function deleteOwner(address owner) onlyRoot public returns (bool) {
require(owner != root);
delete owners[owner];
return true;
}
}
contract LockableToken is StandardToken, MultiOwnable {
bool public locked = true;
uint256 public constant LOCK_MAX = uint256(-1);
mapping(address => bool) public unlockAddrs;
mapping(address => uint256) public lockValues;
event Locked(bool locked, string note);
event LockedTo(address indexed addr, bool locked, string note);
event SetLockValue(address indexed addr, uint256 value, string note);
constructor() public {
unlockTo(msg.sender, "");
}
modifier checkUnlock (address addr, uint256 value) {
require(!locked || unlockAddrs[addr]);
require(balances[addr].sub(value) >= lockValues[addr]);
_;
}
function lock(string note) onlyOwner public {
locked = true;
emit Locked(locked, note);
}
function unlock(string note) onlyOwner public {
locked = false;
emit Locked(locked, note);
}
function lockTo(address addr, string note) onlyOwner public {
require(addr != root);
setLockValue(addr, LOCK_MAX, note);
unlockAddrs[addr] = false;
emit LockedTo(addr, true, note);
}
function unlockTo(address addr, string note) onlyOwner public {
if (lockValues[addr] == LOCK_MAX)
setLockValue(addr, 0, note);
unlockAddrs[addr] = true;
emit LockedTo(addr, false, note);
}
function setLockValue(address addr, uint256 value, string note) onlyOwner public {
lockValues[addr] = value;
emit SetLockValue(addr, value, note);
}
function getMyUnlockValue() public view returns (uint256) {
address addr = msg.sender;
if ((!locked || unlockAddrs[addr]) && balances[addr] >= lockValues[addr])
return balances[addr].sub(lockValues[addr]);
else
return 0;
}
function transfer(address to, uint256 value) checkUnlock(msg.sender, value) public returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) checkUnlock(from, value) public returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract KSCBaseToken is LockableToken {
using AddressUtils for address;
event KSCTransfer(address indexed from, address indexed to, uint256 value, string note);
event KSCTransferFrom(address indexed owner, address indexed spender, address indexed to, uint256 value, string note);
event KSCApproval(address indexed owner, address indexed spender, uint256 value, string note);
event KSCMintTo(address indexed controller, address indexed to, uint256 amount, string note);
event KSCBurnFrom(address indexed controller, address indexed from, uint256 value, string note);
event KSCBurnWhenMoveToMainnet(address indexed controller, address indexed from, uint256 value, string note);
event KSCBurnWhenUseInSidechain(address indexed controller, address indexed from, uint256 value, string note);
event KSCSell(address indexed owner, address indexed spender, address indexed to, uint256 value, string note);
event KSCSellByOtherCoin(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
event KSCTransferToEcosystem(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
event KSCTransferToBounty(address indexed owner, address indexed spender, address indexed to, uint256 value, uint256 processIdHash, uint256 userIdHash, string note);
// ERC20 super ksc~ .
function transfer(address to, uint256 value) public returns (bool ret) {
return kscTransfer(to, value, "");
}
function kscTransfer(address to, uint256 value, string note) public returns (bool ret) {
require(to != address(this));
ret = super.transfer(to, value);
emit KSCTransfer(msg.sender, to, value, note);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
return kscTransferFrom(from, to, value, "");
}
function kscTransferFrom(address from, address to, uint256 value, string note) public returns (bool ret) {
require(to != address(this));
ret = super.transferFrom(from, to, value);
emit KSCTransferFrom(from, msg.sender, to, value, note);
}
function approve(address spender, uint256 value) public returns (bool) {
return kscApprove(spender, value, "");
}
function kscApprove(address spender, uint256 value, string note) public returns (bool ret) {
ret = super.approve(spender, value);
emit KSCApproval(msg.sender, spender, value, note);
}
function increaseApproval(address spender, uint256 addedValue) public returns (bool) {
return kscIncreaseApproval(spender, addedValue, "");
}
function kscIncreaseApproval(address spender, uint256 addedValue, string note) public returns (bool ret) {
ret = super.increaseApproval(spender, addedValue);
emit KSCApproval(msg.sender, spender, allowed[msg.sender][spender], note);
}
function decreaseApproval(address spender, uint256 subtractedValue) public returns (bool) {
return kscDecreaseApproval(spender, subtractedValue, "");
}
function kscDecreaseApproval(address spender, uint256 subtractedValue, string note) public returns (bool ret) {
ret = super.decreaseApproval(spender, subtractedValue);
emit KSCApproval(msg.sender, spender, allowed[msg.sender][spender], note);
}
function mintTo(address to, uint256 amount) internal returns (bool) {
require(to != address(0x0));
totalSupply_ = totalSupply_.add(amount);
balances[to] = balances[to].add(amount);
emit Transfer(address(0), to, amount);
return true;
}
function kscMintTo(address to, uint256 amount, string note) onlyOwner public returns (bool ret) {
ret = mintTo(to, amount);
emit KSCMintTo(msg.sender, to, amount, note);
}
function burnFrom(address from, uint256 value) internal returns (bool) {
require(value <= balances[from]);
balances[from] = balances[from].sub(value);
totalSupply_ = totalSupply_.sub(value);
emit Transfer(from, address(0), value);
return true;
}
function kscBurnFrom(address from, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(from, value);
emit KSCBurnFrom(msg.sender, from, value, note);
}
function kscBurnWhenMoveToMainnet(address burner, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(burner, value);
emit KSCBurnWhenMoveToMainnet(msg.sender, burner, value, note);
}
function kscBatchBurnWhenMoveToMainnet(address[] burners, uint256[] values, string note) onlyOwner public returns (bool ret) {
uint256 length = burners.length;
require(length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
ret = ret && kscBurnWhenMoveToMainnet(burners[i], values[i], note);
}
}
function kscBurnWhenUseInSidechain(address burner, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = burnFrom(burner, value);
emit KSCBurnWhenUseInSidechain(msg.sender, burner, value, note);
}
function kscBatchBurnWhenUseInSidechain(address[] burners, uint256[] values, string note) onlyOwner public returns (bool ret) {
uint256 length = burners.length;
require(length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
ret = ret && kscBurnWhenUseInSidechain(burners[i], values[i], note);
}
}
function kscSell(address from, address to, uint256 value, string note) onlyOwner public returns (bool ret) {
require(to != address(this));
ret = super.transferFrom(from, to, value);
emit KSCSell(from, msg.sender, to, value, note);
}
function kscBatchSellByOtherCoin(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(length == values.length);
require(length == userIdHash.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCSellByOtherCoin(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function kscBatchTransferToEcosystem(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(length == values.length);
require(length == userIdHash.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCTransferToEcosystem(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function kscBatchTransferToBounty(address from, address[] to, uint256[] values, uint256 processIdHash, uint256[] userIdHash, string note) onlyOwner public returns (bool ret) {
uint256 length = to.length;
require(to.length == values.length);
ret = true;
for (uint256 i = 0; i < length; i++) {
require(to[i] != address(this));
ret = ret && super.transferFrom(from, to[i], values[i]);
emit KSCTransferToBounty(from, msg.sender, to[i], values[i], processIdHash, userIdHash[i], note);
}
}
function destroy() onlyRoot public {
selfdestruct(root);
}
}
contract KStarCoin is KSCBaseToken {
using AddressUtils for address;
string public constant name = "KStarCoin";
string public constant symbol = "KSC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1e9 * (10 ** uint256(decimals));
bytes4 internal constant KSC_RECEIVED = 0xe6947547; // KSCReceiver.onKSCReceived.selector
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function kscTransfer(address to, uint256 value, string note) public returns (bool ret) {
ret = super.kscTransfer(to, value, note);
require(postTransfer(msg.sender, msg.sender, to, value, KSCReceiver.KSCReceiveType.KSC_TRANSFER));
}
function kscTransferFrom(address from, address to, uint256 value, string note) public returns (bool ret) {
ret = super.kscTransferFrom(from, to, value, note);
require(postTransfer(from, msg.sender, to, value, KSCReceiver.KSCReceiveType.KSC_TRANSFER));
}
function postTransfer(address owner, address spender, address to, uint256 value, KSCReceiver.KSCReceiveType receiveType) internal returns (bool) {
if (!to.isContract())
return true;
bytes4 retval = KSCReceiver(to).onKSCReceived(owner, spender, value, receiveType);
return (retval == KSC_RECEIVED);
}
function kscMintTo(address to, uint256 amount, string note) onlyOwner public returns (bool ret) {
ret = super.kscMintTo(to, amount, note);
require(postTransfer(0x0, msg.sender, to, amount, KSCReceiver.KSCReceiveType.KSC_MINT));
}
function kscBurnFrom(address from, uint256 value, string note) onlyOwner public returns (bool ret) {
ret = super.kscBurnFrom(from, value, note);
require(postTransfer(0x0, msg.sender, from, value, KSCReceiver.KSCReceiveType.KSC_BURN));
}
}
contract KSCReceiver {
bytes4 internal constant KSC_RECEIVED = 0xe6947547; // this.onKSCReceived.selector
enum KSCReceiveType { KSC_TRANSFER, KSC_MINT, KSC_BURN }
function onKSCReceived(address owner, address spender, uint256 value, KSCReceiveType receiveType) public returns (bytes4);
}
contract KSCDappSample is KSCReceiver {
event LogOnReceiveKSC(string message, address indexed owner, address indexed spender, uint256 value, KSCReceiveType receiveType);
function onKSCReceived(address owner, address spender, uint256 value, KSCReceiveType receiveType) public returns (bytes4) {
emit LogOnReceiveKSC("I receive KstarCoin.", owner, spender, value, receiveType);
return KSC_RECEIVED; // must return this value if successful
}
}
| 147,260 | 11,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.