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
|
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d59c18ac0447e598b3ff89dac490b0eaa2e0c43b6736a4a685a72c21df099156
| 39,322 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ae/ae7420f427f7d4326d97a004c2446df044f58b6a_Cronjeshare.sol
| 4,982 | 19,759 |
// https://app.cronjetomb.finance/
// https://docs.cronjetomb.finance/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 50;
string private _name = "Cronje Share";
string private _symbol = "CSHARE";
uint8 private _decimals = 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 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"));
}
}
// Cronjeshare with Governance.
contract Cronjeshare is BEP20("Cronjeshare", "CSHARE") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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,
"CAKE::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 CAKEs (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,
"CAKE::_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;
}
}
| 312,123 | 11,800 |
c8429e4a467309d4a960da1444d71d8d07f8a30d8680bca66860ba71e7555a8d
| 15,323 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xfaa68bca10f557ad760f07c81ae15bc3d9aa4231.sol
| 2,772 | 10,267 |
pragma solidity ^0.4.19;
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/DisableSelfTransfer.sol
contract DisableSelfTransfer is StandardToken {
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(this));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(this));
return super.transferFrom(_from, _to, _value);
}
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/OwnerContract.sol
contract OwnerContract is Ownable {
mapping (address => bool) internal contracts;
// New modifier to be used in place of OWNER ONLY activity
// Eventually this will be owned by a controller contract and not a private wallet
// (Voting needs to be implemented)
modifier justOwner() {
require(msg.sender == owner);
_;
}
// Allow contracts to have ownership without taking full custody of the token
// (Until voting is fully implemented)
modifier onlyOwner() {
if (msg.sender == address(0) || (msg.sender != owner && !contracts[msg.sender])) {
revert(); // error for uncontrolled request
}
_;
}
// Stops owner from gaining access to all functionality
modifier onlyContract() {
require(msg.sender != address(0));
require(contracts[msg.sender]);
_;
}
// new owner only activity.
// (Voting to be implemented for owner replacement)
function removeController(address controllerToRemove) public justOwner {
require(contracts[controllerToRemove]);
contracts[controllerToRemove] = false;
}
// new owner only activity.
// (Voting to be implemented for owner replacement)
function addController(address newController) public justOwner {
contracts[newController] = true;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/MintableContractOwnerToken.sol
contract MintableContractOwnerToken is MintableToken, BurnableToken, OwnerContract, DisableSelfTransfer {
bool burnAllowed = false;
// Fired when an approved contract calls restartMint
event MintRestarted();
// Fired when a transfer is initiated from the contract rather than the owning wallet.
event ContractTransfer(address from, address to, uint value);
// Fired when burning status changes
event BurningStateChange(bool canBurn);
// opposite of canMint used for restarting the mint
modifier cantMint() {
require(mintingFinished);
_;
}
// Require Burn to be turned on
modifier canBurn() {
require(burnAllowed);
_;
}
// Require that burning is turned off
modifier cantBurn() {
require(!burnAllowed);
_;
}
// Enable Burning Only if Burning is Off
function enableBurning() public onlyContract cantBurn {
burnAllowed = true;
BurningStateChange(burnAllowed);
}
// Disable Burning Only if Burning is On
function disableBurning() public onlyContract canBurn {
burnAllowed = false;
BurningStateChange(burnAllowed);
}
// Override parent burn function to provide canBurn limitation
function burn(uint256 _value) public canBurn {
super.burn(_value);
}
// Allow the contract to approve the mint restart
// (Voting will be essential in these actions)
function restartMinting() onlyContract cantMint public returns (bool) {
mintingFinished = false;
MintRestarted(); // Notify the blockchain that the coin minting was restarted
return true;
}
// Allow owner or contract to finish minting.
function finishMinting() onlyOwner canMint public returns (bool) {
return super.finishMinting();
}
// Allow the system to create transactions for transfers when appropriate.
// (e.g. upgrading the token for everyone, voting to recover accounts for lost private keys,
// (Must be voted for on an approved contract to gain access to this function)
function contractTransfer(address _from, address _to, uint256 _value) public onlyContract returns (bool) {
require(_from != address(0));
require(_to != address(0));
require(_value > 0);
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractTransfer(_from, _to, _value); // Notify blockchain the following transaction was contract initiated
Transfer(_from, _to, _value); // Call original transfer event to maintain compatibility with stardard transaction systems
return true;
}
}
// File: contracts/LazyCoderCoin.sol
contract LazyCoderCoin is MintableContractOwnerToken {
string public name = "LazyCoder Coin";
string public symbol = "TLC";
uint8 public decimals = 18;
function LazyCoderCoin() public {
}
}
| 208,596 | 11,801 |
2b9e8642ff0fce6988c41e95ab838ef63296ed91da23704230f479bee890492d
| 9,457 |
.sol
|
Solidity
| false |
449763406
|
joswha/Replaying-ETH-Attacks
|
7ee09cebb752cbac399c9ad08743444353fe9c31
|
contracts/powh/PonziTokenV3.sol
| 3,310 | 9,107 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract PonziTokenV3 {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ProofOfWeakHands";
string constant public symbol = "POWH";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function PonziTokenV3() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 259,202 | 11,802 |
7f2dfbe6f8e81f3986eee5cb3166db8515d08423fd57c4677b75c6ee845e44f0
| 17,121 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3c3f82ea193535e4e94dfbce8ac771f361cfedd6.sol
| 3,155 | 11,603 |
pragma solidity ^0.4.23;
// File: contracts/helpers/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/helpers/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/token/ERC20Interface.sol
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
// File: contracts/token/BaseToken.sol
contract BaseToken is ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
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 allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/token/MintableToken.sol
contract MintableToken is BaseToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: contracts/token/CappedToken.sol
contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
// File: contracts/helpers/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// File: contracts/token/PausableToken.sol
contract PausableToken is BaseToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/token/SignedTransferToken.sol
contract SignedTransferToken is BaseToken {
event TransferPreSigned(address indexed from,
address indexed to,
address indexed settler,
uint256 value,
uint256 fee);
// Mapping of already executed settlements for a given address
mapping(address => mapping(bytes32 => bool)) internal executedSettlements;
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public returns (bool) {
uint256 total = _value.add(_fee);
bytes32 calcHash = calculateHash(_from, _to, _value, _fee, _nonce);
require(_to != address(0));
require(isValidSignature(_from, calcHash, _v, _r, _s));
require(balances[_from] >= total);
require(!executedSettlements[_from][calcHash]);
executedSettlements[_from][calcHash] = true;
// Move tokens
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
// Move fee
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(_from, msg.sender, _fee);
emit TransferPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public returns (bool) {
// Make sure all the arrays are of the same length
require(_from.length == _to.length &&
_to.length ==_values.length &&
_values.length == _fees.length &&
_fees.length == _nonces.length &&
_nonces.length == _v.length &&
_v.length == _r.length &&
_r.length == _s.length);
for(uint i; i < _from.length; i++) {
transferPreSigned(_from[i],
_to[i],
_values[i],
_fees[i],
_nonces[i],
_v[i],
_r[i],
_s[i]);
}
return true;
}
function calculateHash(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce) public view returns (bytes32) {
return keccak256(abi.encodePacked(uint256(0), address(this), _from, _to, _value, _fee, _nonce));
}
function isValidSignature(address _signer, bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (bool) {
return _signer == ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)),
_v,
_r,
_s);
}
function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) {
return executedSettlements[_from][_calcHash];
}
}
// File: contracts/token/PausableSignedTransferToken.sol
contract PausableSignedTransferToken is SignedTransferToken, PausableToken {
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSigned(_from, _to, _value, _fee, _nonce, _v, _r, _s);
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public whenNotPaused returns (bool) {
return super.transferPreSignedBulk(_from, _to, _values, _fees, _nonces, _v, _r, _s);
}
}
// File: contracts/ElesToken.sol
contract ElesToken is CappedToken, PausableSignedTransferToken {
string public name = 'Elements Estates Token';
string public symbol = 'ELES';
uint256 public decimals = 18;
// Max supply of 250 million
uint256 internal maxSupply = 250000000 * 10**decimals;
constructor()
CappedToken(maxSupply) public {
paused = true;
}
// @dev Recover any mistakenly sent ERC20 tokens to the Token address
function recoverERC20Tokens(address _erc20, uint256 _amount) public onlyOwner {
ERC20Interface(_erc20).transfer(msg.sender, _amount);
}
}
| 213,871 | 11,803 |
ae27a79fb90b326e92316a25798e2a488092eba325d97003a26042b77485f1c9
| 17,369 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/12/124b4276d44b4e3e9e5a3ac06a1cacdd36ff053b_Distributor.sol
| 3,392 | 13,870 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable TIME;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _time, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_time != address(0));
TIME = IERC20(_time);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return TIME.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 84,635 | 11,804 |
5c5f7e39c9128be9d266fa2c358be611faf034834558c08cea55393d68dd64c9
| 29,512 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/7b/7bf1446b3b41271031950303670b7bbb39638747_SAITAMA.sol
| 5,182 | 18,686 |
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 SAITAMA is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'SAITAMA';
string private constant _symbol = 'SAITAMA';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x708BBb821d88517f671B220BF4f0C3462B2c2EA1, '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;
}
}
| 330,030 | 11,805 |
a28a814f0dc9ebbf4563962089303f26cc28bd1e9d312842976890e51788ef1d
| 9,324 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x495c0c519a8d8f171a8952fc0e97a7c354685ab7.sol
| 2,246 | 8,556 |
pragma solidity ^0.4.25;
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;
}
}
/// @title Role based access control mixin for Rasmart Platform
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Ignore DRY approach to achieve readability
contract RBACMixin {
/// @notice Constant string message to throw on lack of access
string constant FORBIDDEN = "Haven't enough right to access";
/// @notice Public map of owners
mapping (address => bool) public owners;
/// @notice Public map of minters
mapping (address => bool) public minters;
/// @notice The event indicates the addition of a new owner
/// @param who is address of added owner
event AddOwner(address indexed who);
/// @notice The event indicates the deletion of an owner
/// @param who is address of deleted owner
event DeleteOwner(address indexed who);
/// @notice The event indicates the addition of a new minter
/// @param who is address of added minter
event AddMinter(address indexed who);
/// @notice The event indicates the deletion of a minter
/// @param who is address of deleted minter
event DeleteMinter(address indexed who);
constructor () public {
_setOwner(msg.sender, true);
}
/// @notice The functional modifier rejects the interaction of senders who are not owners
modifier onlyOwner() {
require(isOwner(msg.sender), FORBIDDEN);
_;
}
/// @notice Functional modifier for rejecting the interaction of senders that are not minters
modifier onlyMinter() {
require(isMinter(msg.sender), FORBIDDEN);
_;
}
/// @notice Look up for the owner role on providen address
/// @param _who is address to look up
/// @return A boolean of owner role
function isOwner(address _who) public view returns (bool) {
return owners[_who];
}
/// @notice Look up for the minter role on providen address
/// @param _who is address to look up
/// @return A boolean of minter role
function isMinter(address _who) public view returns (bool) {
return minters[_who];
}
/// @notice Adds the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, true);
}
/// @notice Deletes the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, false);
}
/// @notice Adds the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, true);
}
/// @notice Deletes the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, false);
}
/// @notice Changes the owner role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setOwner(address _who, bool _flag) private returns (bool) {
require(owners[_who] != _flag);
owners[_who] = _flag;
if (_flag) {
emit AddOwner(_who);
} else {
emit DeleteOwner(_who);
}
return true;
}
/// @notice Changes the minter role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setMinter(address _who, bool _flag) private returns (bool) {
require(minters[_who] != _flag);
minters[_who] = _flag;
if (_flag) {
emit AddMinter(_who);
} else {
emit DeleteMinter(_who);
}
return true;
}
}
interface IMintableToken {
function mint(address _to, uint256 _amount) external returns (bool);
}
/// @title Very simplified implementation of Token Bucket Algorithm to secure token minting
/// @author Mai Abha <maiabha82@gmail.com>
/// @notice Works with tokens implemented Mintable interface
contract AdvisorsBucket is RBACMixin, IMintableToken {
using SafeMath for uint;
/// @notice Limit maximum amount of available for minting tokens when bucket is full
uint256 public size;
/// @notice Bucket refill rate
uint256 public rate;
/// @notice Stored time of latest minting
/// @dev Each successful call of minting function will update field with call timestamp
uint256 public lastMintTime;
/// @notice Left tokens in bucket on time of latest minting
uint256 public leftOnLastMint;
/// @notice Reference of Mintable token
/// @dev Setup in contructor phase and never change in future
IMintableToken public token;
/// @notice Token Bucket leak event fires on each minting
/// @param to is address of target tokens holder
/// @param left is amount of tokens available in bucket after leak
event Leak(address indexed to, uint256 left);
/// @param _token is address of Mintable token
/// @param _size initial size of token bucket
/// @param _rate initial refill rate (tokens/sec)
constructor (address _token, uint256 _size, uint256 _rate) public {
token = IMintableToken(_token);
size = _size;
rate = _rate;
leftOnLastMint = _size;
}
/// @notice Change size of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @return A boolean that indicates if the operation was successful.
function setSize(uint256 _size) public onlyOwner returns (bool) {
size = _size;
return true;
}
/// @notice Change refill rate of bucket
/// @dev Require owner role to call
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setRate(uint256 _rate) public onlyOwner returns (bool) {
rate = _rate;
return true;
}
/// @notice Change size and refill rate of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setSizeAndRate(uint256 _size, uint256 _rate) public onlyOwner returns (bool) {
return setSize(_size) && setRate(_rate);
}
/// @notice Function to mint tokens
/// @param _to The address that will receive the minted tokens.
/// @param _amount The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address _to, uint256 _amount) public onlyMinter returns (bool) {
uint256 available = availableTokens();
require(_amount <= available);
leftOnLastMint = available.sub(_amount);
lastMintTime = now; // solium-disable-line security/no-block-members
require(token.mint(_to, _amount));
return true;
}
/// @notice Function to calculate and get available in bucket tokens
/// @return An amount of available tokens in bucket
function availableTokens() public view returns (uint) {
// solium-disable-next-line security/no-block-members
uint256 timeAfterMint = now.sub(lastMintTime);
uint256 refillAmount = rate.mul(timeAfterMint).add(leftOnLastMint);
return size < refillAmount ? size : refillAmount;
}
}
| 185,927 | 11,806 |
4b0270a91dec41a8733d855d9d0c0686aa3c0364102c42d0f674c188824393d6
| 10,872 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xB3DD9429035c29CC787d50ffcd14dE9E35657c9D.sol
| 3,627 | 10,459 |
pragma solidity >= 0.6.3 < 0.7.0;
contract EthernityMoney {
address public creator;
uint MAX_LEVEL = 9;
uint REFERRALS_LIMIT = 2;
uint LEVEL_EXPIRE_TIME = 111 days;
uint LEVEL_HIGHER_FOUR_EXPIRE_TIME = 10000 days;
mapping (address => User) public users;
mapping (uint => address) public userAddresses;
uint public last_uid;
mapping (uint => uint) public levelPrice;
mapping (uint => uint) public uplinesToRcvEth;
mapping (address => ProfitsRcvd) public rcvdProfits;
mapping (address => ProfitsGiven) public givenProfits;
mapping (address => LostProfits) public lostProfits;
struct User {
uint id;
uint referrerID;
address[] referrals;
mapping (uint => uint) levelExpiresAt;
}
struct ProfitsRcvd {
uint uid;
uint[] fromId;
address[] fromAddr;
uint[] amount;
}
struct LostProfits {
uint uid;
uint[] toId;
address[] toAddr;
uint[] amount;
uint[] level;
}
struct ProfitsGiven {
uint uid;
uint[] toId;
address[] toAddr;
uint[] amount;
uint[] level;
uint[] line;
}
modifier validLevelAmount(uint _level) {
require(msg.value == levelPrice[_level], 'Invalid level amount sent');
_;
}
modifier userRegistered() {
require(users[msg.sender].id != 0, 'User does not exist');
_;
}
modifier validReferrerID(uint _referrerID) {
require(_referrerID > 0 && _referrerID <= last_uid, 'Invalid referrer ID');
_;
}
modifier userNotRegistered() {
require(users[msg.sender].id == 0, 'User is already registered');
_;
}
modifier validLevel(uint _level) {
require(_level > 0 && _level <= MAX_LEVEL, 'Invalid level entered');
_;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint time);
event BuyLevelEvent(address indexed user, uint indexed level, uint time);
event GetLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
event LostLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
constructor() public {
last_uid++;
creator = msg.sender;
levelPrice[1] = 0.30 ether;
levelPrice[2] = 0.72 ether;
levelPrice[3] = 1.96 ether;
levelPrice[4] = 4.00 ether;
levelPrice[5] = 8.10 ether;
levelPrice[6] = 15.00 ether;
levelPrice[7] = 20.90 ether;
levelPrice[8] = 35.40 ether;
levelPrice[9] = 50.70 ether;
uplinesToRcvEth[1] = 5;
uplinesToRcvEth[2] = 6;
uplinesToRcvEth[3] = 7;
uplinesToRcvEth[4] = 8;
uplinesToRcvEth[5] = 9;
uplinesToRcvEth[6] = 10;
uplinesToRcvEth[7] = 11;
uplinesToRcvEth[8] = 12;
uplinesToRcvEth[9] = 13;
users[creator] = User({
id: last_uid,
referrerID: 0,
referrals: new address[](0)
});
userAddresses[last_uid] = creator;
for (uint i = 1; i <= MAX_LEVEL; i++) {
users[creator].levelExpiresAt[i] = 1 << 37;
}
}
function registerUser(uint _referrerID) public payable userNotRegistered() validReferrerID(_referrerID) validLevelAmount(1) {
uint _level = 1;
if (users[userAddresses[_referrerID]].referrals.length >= REFERRALS_LIMIT) {
_referrerID = users[findReferrer(userAddresses[_referrerID])].id;
}
last_uid++;
users[msg.sender] = User({
id: last_uid,
referrerID: _referrerID,
referrals: new address[](0)
});
userAddresses[last_uid] = msg.sender;
users[msg.sender].levelExpiresAt[_level] = now + getLevelExpireTime(_level);
users[userAddresses[_referrerID]].referrals.push(msg.sender);
transferLevelPayment(_level, msg.sender);
emit RegisterUserEvent(msg.sender, userAddresses[_referrerID], now);
}
function buyLevel(uint _level) public payable userRegistered() validLevel(_level) validLevelAmount(_level) {
for (uint l = _level - 1; l > 0; l--) {
require(getUserLevelExpiresAt(msg.sender, l) >= now, 'Buy previous level first');
}
if (getUserLevelExpiresAt(msg.sender, _level) == 0) {
users[msg.sender].levelExpiresAt[_level] = now + getLevelExpireTime(_level);
} else {
users[msg.sender].levelExpiresAt[_level] += getLevelExpireTime(_level);
}
transferLevelPayment(_level, msg.sender);
emit BuyLevelEvent(msg.sender, _level, now);
}
function getLevelExpireTime(uint _level) public view returns (uint) {
if (_level < 5) {
return LEVEL_EXPIRE_TIME;
} else {
return LEVEL_HIGHER_FOUR_EXPIRE_TIME;
}
}
function findReferrer(address _user) public view returns (address) {
if (users[_user].referrals.length < REFERRALS_LIMIT) {
return _user;
}
address[1632] memory referrals;
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
address referrer;
for (uint i = 0; i < 16382; i++) {
if (users[referrals[i]].referrals.length < REFERRALS_LIMIT) {
referrer = referrals[i];
break;
}
if (i >= 8191) {
continue;
}
referrals[(i+1)*2] = users[referrals[i]].referrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].referrals[1];
}
require(referrer != address(0), 'Referrer not found');
return referrer;
}
function transferLevelPayment(uint _level, address _user) internal {
uint height = _level;
address referrer = getUserUpline(_user, height);
if (referrer == address(0)) {
referrer = creator;
}
uint uplines = uplinesToRcvEth[_level];
bool chkLostProfit = false;
address lostAddr;
for (uint i = 1; i <= uplines; i++) {
referrer = getUserUpline(_user, i);
if(chkLostProfit){
lostProfits[lostAddr].uid = users[referrer].id;
lostProfits[lostAddr].toId.push(users[referrer].id);
lostProfits[lostAddr].toAddr.push(referrer);
lostProfits[lostAddr].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]);
lostProfits[lostAddr].level.push(getUserLevel(referrer));
chkLostProfit = false;
emit LostLevelProfitEvent(referrer, msg.sender, _level, 0);
}
if (referrer != address(0) && (users[_user].levelExpiresAt[_level] == 0 || getUserLevelExpiresAt(referrer, _level) < now)) {
chkLostProfit = true;
uplines++;
lostAddr = referrer;
continue;
} else {
chkLostProfit = false;
}
if (referrer == address(0)) {
referrer = creator;
}
if (address(uint160(referrer)).send(msg.value / uplinesToRcvEth[_level])) {
rcvdProfits[referrer].uid = users[referrer].id;
rcvdProfits[referrer].fromId.push(users[msg.sender].id);
rcvdProfits[referrer].fromAddr.push(msg.sender);
rcvdProfits[referrer].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]);
givenProfits[msg.sender].uid = users[msg.sender].id;
givenProfits[msg.sender].toId.push(users[referrer].id);
givenProfits[msg.sender].toAddr.push(referrer);
givenProfits[msg.sender].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]);
givenProfits[msg.sender].level.push(getUserLevel(referrer));
givenProfits[msg.sender].line.push(i);
emit GetLevelProfitEvent(referrer, msg.sender, _level, now);
}
}
}
function getUserUpline(address _user, uint height) public view returns (address) {
if (height <= 0 || _user == address(0)) {
return _user;
}
return this.getUserUpline(userAddresses[users[_user].referrerID], height - 1);
}
function getUserReferrals(address _user) public view returns (address[] memory) {
return users[_user].referrals;
}
function getUserProfitsFromId(address _user) public view returns (uint[] memory) {
return rcvdProfits[_user].fromId;
}
function getUserProfitsFromAddr(address _user) public view returns (address[] memory) {
return rcvdProfits[_user].fromAddr;
}
function getUserProfitsAmount(address _user) public view returns (uint256[] memory) {
return rcvdProfits[_user].amount;
}
function getUserProfitsGivenToId(address _user) public view returns (uint[] memory) {
return givenProfits[_user].toId;
}
function getUserProfitsGivenToAddr(address _user) public view returns (address[] memory) {
return givenProfits[_user].toAddr;
}
function getUserProfitsGivenToAmount(address _user) public view returns (uint[] memory) {
return givenProfits[_user].amount;
}
function getUserProfitsGivenToLevel(address _user) public view returns (uint[] memory) {
return givenProfits[_user].level;
}
function getUserProfitsGivenToLine(address _user) public view returns (uint[] memory) {
return givenProfits[_user].line;
}
function getUserLostsToId(address _user) public view returns (uint[] memory) {
return (lostProfits[_user].toId);
}
function getUserLostsToAddr(address _user) public view returns (address[] memory) {
return (lostProfits[_user].toAddr);
}
function getUserLostsAmount(address _user) public view returns (uint[] memory) {
return (lostProfits[_user].amount);
}
function getUserLostsLevel(address _user) public view returns (uint[] memory) {
return (lostProfits[_user].level);
}
function getUserLevelExpiresAt(address _user, uint _level) public view returns (uint) {
return users[_user].levelExpiresAt[_level];
}
function getUserLevel (address _user) public view returns (uint) {
if (getUserLevelExpiresAt(_user, 1) < now) {
return (0);
} else if (getUserLevelExpiresAt(_user, 2) < now) {
return (1);
} else if (getUserLevelExpiresAt(_user, 3) < now) {
return (2);
} else if (getUserLevelExpiresAt(_user, 4) < now) {
return (3);
} else if (getUserLevelExpiresAt(_user, 5) < now) {
return (4);
} else if (getUserLevelExpiresAt(_user, 6) < now) {
return (5);
} else if (getUserLevelExpiresAt(_user, 7) < now) {
return (6);
} else if (getUserLevelExpiresAt(_user, 8) < now) {
return (7);
} else if (getUserLevelExpiresAt(_user, 9) < now) {
return (8);
} else if (getUserLevelExpiresAt(_user, 10) < now) {
return (9);
}
}
function getUserDetails (address _user) public view returns (uint, uint) {
if (getUserLevelExpiresAt(_user, 1) < now) {
return (1, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 2) < now) {
return (2, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 3) < now) {
return (3, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 4) < now) {
return (4, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 5) < now) {
return (5, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 6) < now) {
return (6, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 7) < now) {
return (7, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 8) < now) {
return (8, users[_user].id);
} else if (getUserLevelExpiresAt(_user, 9) < now) {
return (9, users[_user].id);
}
}
receive() external payable {
revert();
}
}
| 336,024 | 11,807 |
ba7e2a7d91cc5d9cfc1f9a4ec02365727ba46f2ac4c396e18e0af18da167fd20
| 39,220 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1b/1b0f26a18c1bc6c08b3f5f9d0371e118fe75dabc_ape.sol
| 4,951 | 19,661 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 2000;
string private _name = "Fantom Ape";
string private _symbol = "APE";
uint8 private _decimals = 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 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"));
}
}
// ape with Governance.
contract ape is BEP20("Fantom APE", "APE") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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,
"CAKE::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 CAKEs (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,
"CAKE::_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;
}
}
| 331,545 | 11,808 |
813f0048f13b4a379444ce5acde241489fbf97f68c0b02afbb44300a5a2a222c
| 22,525 |
.sol
|
Solidity
| false |
388150634
|
candlegenie/solidity
|
99c25153b82e4295145234049d0a967dcba26c18
|
CandleGeniePredictions.sol
| 4,679 | 19,169 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
//CONTEXT
abstract contract Context
{
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// REENTRANCY GUARD
abstract contract ReentrancyGuard
{
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
//OWNABLE
abstract contract Ownable is Context
{
address public _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 OwnershipRenounce() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function OwnershipTransfer(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//PAUSABLE
abstract contract Pausable is Context
{
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
//PREDICTIONS
contract CandleGeniePredictionV3 is Ownable, Pausable, ReentrancyGuard
{
struct Round
{
uint256 epoch;
uint256 bullAmount;
uint256 bearAmount;
uint256 rewardBaseCalAmount;
uint256 rewardAmount;
int256 lockPrice;
int256 closePrice;
uint32 startTimestamp;
uint32 lockTimestamp;
uint32 closeTimestamp;
uint32 lockPriceTimestamp;
uint32 closePriceTimestamp;
bool closed;
bool cancelled;
}
enum Position {Bull, Bear}
struct BetInfo {
Position position;
uint256 amount;
bool claimed; // default false
}
mapping(uint256 => Round) public Rounds;
mapping(uint256 => mapping(address => BetInfo)) public Bets;
mapping(address => uint256[]) public UserBets;
mapping(address=>bool) internal Blacklist;
uint256 public currentEpoch;
address public operatorAddress;
string public priceSource;
// Defaults
uint256 public rewardRate = 97; // Prize reward rate
uint256 constant internal minimumRewardRate = 90; // Minimum reward rate 90%
uint256 public intervalSeconds = 300;
uint256 public minBetAmount = 1000000000000000;
uint256 public bufferSeconds = 30;
bool public startOnce = false;
bool public lockOnce = false;
event BetBear(address indexed sender, uint256 indexed epoch, uint256 amount);
event BetBull(address indexed sender, uint256 indexed epoch, uint256 amount);
event HouseBet(address indexed sender, uint256 indexed epoch, uint256 bullAmount, uint256 bearAmount);
event LockRound(uint256 indexed epoch, int256 price, uint32 timestamp);
event EndRound(uint256 indexed epoch, int256 price, uint32 timestamp);
event Claim(address indexed sender, uint256 indexed epoch, uint256 amount);
event StartRound(uint256 indexed epoch);
event CancelRound(uint256 indexed epoch);
event Pause(uint256 indexed epoch);
event Unpause(uint256 indexed epoch);
event RewardsCalculated(uint256 indexed epoch,
uint256 rewardBaseCalAmount,
uint256 rewardAmount);
event InjectFunds(address indexed sender);
event MinBetAmountUpdated(uint256 indexed epoch, uint256 minBetAmount);
event BufferAndIntervalSecondsUpdated(uint256 bufferSeconds, uint256 intervalSeconds);
event NewPriceSource(string priceSource);
constructor(address _operatorAddress)
{
operatorAddress = _operatorAddress;
}
modifier onlyOwnerOrOperator()
{
require(msg.sender == _owner || msg.sender == operatorAddress, "Only owner or operator can call this function");
_;
}
modifier notContract()
{
require(!_isContract(msg.sender), "contract not allowed");
require(msg.sender == tx.origin, "proxy contract not allowed");
_;
}
// INTERNAL FUNCTIONS ---------------->
function _safeStartRound(uint256 epoch) internal
{
Round storage round = Rounds[epoch];
round.startTimestamp = uint32(block.timestamp);
round.lockTimestamp = uint32(block.timestamp + intervalSeconds);
round.closeTimestamp = uint32(block.timestamp + (2 * intervalSeconds));
round.epoch = epoch;
emit StartRound(epoch);
}
function _safeLockRound(uint256 epoch, int256 price, uint32 timestamp) internal
{
require(Rounds[epoch].startTimestamp != 0, "Can only lock round after round has started");
require(block.timestamp >= Rounds[epoch].lockTimestamp, "Can only lock round after lock timestamp");
require(block.timestamp <= Rounds[epoch].closeTimestamp, "Can only lock before end timestamp");
Round storage round = Rounds[epoch];
round.lockPrice = price;
round.lockPriceTimestamp = timestamp;
emit LockRound(epoch, price, timestamp);
}
function _safeEndRound(uint256 epoch, int256 price, uint32 timestamp) internal
{
require(Rounds[epoch].lockTimestamp != 0, "Can only end round after round has locked");
require(block.timestamp >= Rounds[epoch].closeTimestamp, "Can only end round after endBlock");
Round storage round = Rounds[epoch];
round.closePrice = price;
round.closePriceTimestamp = timestamp;
round.closed = true;
emit EndRound(epoch, price, timestamp);
}
function _calculateRewards(uint256 epoch) internal
{
require(Rounds[epoch].rewardBaseCalAmount == 0 && Rounds[epoch].rewardAmount == 0, "Rewards calculated");
Round storage round = Rounds[epoch];
uint256 rewardBaseCalAmount;
uint256 rewardAmount;
uint256 totalAmount = round.bullAmount + round.bearAmount;
// Bull wins
if (round.closePrice > round.lockPrice)
{
rewardBaseCalAmount = round.bullAmount;
rewardAmount = totalAmount * rewardRate / 100;
}
// Bear wins
else if (round.closePrice < round.lockPrice)
{
rewardBaseCalAmount = round.bearAmount;
rewardAmount = totalAmount * rewardRate / 100;
}
// House wins
else
{
rewardBaseCalAmount = 0;
rewardAmount = 0;
}
round.rewardBaseCalAmount = rewardBaseCalAmount;
round.rewardAmount = rewardAmount;
emit RewardsCalculated(epoch, rewardBaseCalAmount, rewardAmount);
}
function _safeCancelRound(uint256 epoch, bool cancelled, bool closed) internal
{
Round storage round = Rounds[epoch];
round.cancelled = cancelled;
round.closed = closed;
emit CancelRound(epoch);
}
function _safeTransferBNB(address to, uint256 value) internal
{
(bool success,) = to.call{gas: 23000, value: value}("");
require(success, "Transfer Failed");
}
function _isContract(address addr) internal view returns (bool)
{
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
function _bettable(uint256 epoch) internal view returns (bool)
{
return
Rounds[epoch].startTimestamp != 0 &&
Rounds[epoch].lockTimestamp != 0 &&
block.timestamp > Rounds[epoch].startTimestamp &&
block.timestamp < Rounds[epoch].lockTimestamp;
}
// EXTERNAL FUNCTIONS ---------------->
function owner_SetOperator(address _operatorAddress) external onlyOwner
{
require(_operatorAddress != address(0), "Cannot be zero address");
operatorAddress = _operatorAddress;
}
function owner_FundsInject() external payable onlyOwner
{
emit InjectFunds(msg.sender);
}
function owner_FundsExtract(uint256 value) external onlyOwner
{
_safeTransferBNB(_owner, value);
}
function owner_RewardUser(address user, uint256 value) external onlyOwner
{
_safeTransferBNB(user, value);
}
function owner_BlackListInsert(address _user) public onlyOwner {
require(!Blacklist[_user], "Address already blacklisted");
Blacklist[_user] = true;
}
function owner_BlackListRemove(address _user) public onlyOwner {
require(Blacklist[_user], "Address already whitelisted");
Blacklist[_user] = false;
}
function owner_ChangePriceSource(string memory _priceSource) external onlyOwner
{
require(bytes(_priceSource).length > 0, "Price source can not be empty");
priceSource = _priceSource;
emit NewPriceSource(_priceSource);
}
function owner_HouseBet(uint256 bullAmount, uint256 bearAmount) external onlyOwnerOrOperator whenNotPaused notContract
{
require(_bettable(currentEpoch), "Round not bettable");
require(address(this).balance >= bullAmount + bearAmount, "Contract balance must be greater than house bet totals");
// Putting Bull Bet
if (bullAmount > 0)
{
// Update round data
Round storage round = Rounds[currentEpoch];
round.bullAmount += bullAmount;
// Update user data
BetInfo storage betInfo = Bets[currentEpoch][address(this)];
betInfo.position = Position.Bull;
betInfo.amount = bullAmount;
UserBets[address(this)].push(currentEpoch);
}
// Putting Bear Bet
if (bearAmount > 0)
{
// Update round data
Round storage round = Rounds[currentEpoch];
round.bearAmount += bearAmount;
// Update user data
BetInfo storage betInfo = Bets[currentEpoch][address(this)];
betInfo.position = Position.Bear;
betInfo.amount = bearAmount;
UserBets[address(this)].push(currentEpoch);
}
emit HouseBet(address(this), currentEpoch, bullAmount, bearAmount);
}
function control_Pause() public onlyOwnerOrOperator whenNotPaused
{
_pause();
emit Pause(currentEpoch);
}
function control_Resume() public onlyOwnerOrOperator whenPaused
{
startOnce = false;
lockOnce = false;
_unpause();
emit Unpause(currentEpoch);
}
function control_RoundStart() external onlyOwnerOrOperator whenNotPaused
{
require(!startOnce, "Can only run startRound once");
currentEpoch = currentEpoch + 1;
_safeStartRound(currentEpoch);
startOnce = true;
}
function control_RoundLock(int256 price, uint32 timestamp) external onlyOwnerOrOperator whenNotPaused
{
require(startOnce, "Can only run after startRound is triggered");
require(!lockOnce, "Can only run lockRound once");
_safeLockRound(currentEpoch, price, timestamp);
currentEpoch = currentEpoch + 1;
_safeStartRound(currentEpoch);
lockOnce = true;
}
function control_RoundExecute(int256 price, uint32 timestamp) external onlyOwnerOrOperator whenNotPaused
{
require(startOnce && lockOnce,"Can only run after startRound and lockRound is triggered");
require(Rounds[currentEpoch - 2].closeTimestamp != 0, "Can only start round after round n-2 has ended");
require(block.timestamp >= Rounds[currentEpoch - 2].closeTimestamp, "Can only start new round after round n-2 endBlock");
// CurrentEpoch refers to previous round (n-1)
_safeLockRound(currentEpoch, price, timestamp);
_safeEndRound(currentEpoch - 1, price, timestamp);
_calculateRewards(currentEpoch - 1);
// Increment currentEpoch to current round (n)
currentEpoch = currentEpoch + 1;
_safeStartRound(currentEpoch);
}
function control_RoundCancel(uint256 epoch, bool cancelled, bool closed) external onlyOwner
{
_safeCancelRound(epoch, cancelled, closed);
}
function setBufferAndIntervalSeconds(uint256 _bufferSeconds, uint256 _intervalSeconds) external onlyOwner
{
require(_bufferSeconds < _intervalSeconds, "BufferSeconds must be inferior to intervalSeconds");
bufferSeconds = _bufferSeconds;
intervalSeconds = _intervalSeconds;
emit BufferAndIntervalSecondsUpdated(_bufferSeconds, _intervalSeconds);
}
function settings_SetRewardRate(uint256 _rewardRate) external onlyOwner
{
require(_rewardRate >= minimumRewardRate, "Reward rate can't be lower than minimum reward rate");
rewardRate = _rewardRate;
}
function settings_SetMinBetAmount(uint256 _minBetAmount) external onlyOwner
{
minBetAmount = _minBetAmount;
emit MinBetAmountUpdated(currentEpoch, minBetAmount);
}
function user_BetBull(uint256 epoch) external payable whenNotPaused nonReentrant notContract
{
require(epoch == currentEpoch, "Bet is too early/late");
require(_bettable(epoch), "Round not bettable");
require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount");
require(Bets[epoch][msg.sender].amount == 0, "Can only bet once per round");
require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?");
uint256 amount = msg.value;
Round storage round = Rounds[epoch];
round.bullAmount = round.bullAmount + amount;
// Update user data
BetInfo storage betInfo = Bets[epoch][msg.sender];
betInfo.position = Position.Bull;
betInfo.amount = amount;
UserBets[msg.sender].push(epoch);
emit BetBull(msg.sender, currentEpoch, amount);
}
function user_BetBear(uint256 epoch) external payable whenNotPaused nonReentrant notContract
{
require(epoch == currentEpoch, "Bet is too early/late");
require(_bettable(epoch), "Round not bettable");
require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount");
require(Bets[epoch][msg.sender].amount == 0, "Can only bet once per round");
require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?");
uint256 amount = msg.value;
Round storage round = Rounds[epoch];
round.bearAmount = round.bearAmount + amount;
// Update user data
BetInfo storage betInfo = Bets[epoch][msg.sender];
betInfo.position = Position.Bear;
betInfo.amount = amount;
UserBets[msg.sender].push(epoch);
emit BetBear(msg.sender, epoch, amount);
}
function user_Claim(uint256[] calldata epochs) external nonReentrant notContract
{
uint256 reward; // Initializes reward
for (uint256 i = 0; i < epochs.length; i++) {
require(Rounds[epochs[i]].startTimestamp != 0, "Round has not started");
require(block.timestamp > Rounds[epochs[i]].closeTimestamp, "Round has not ended");
uint256 addedReward = 0;
// Round valid, claim rewards
if (Rounds[epochs[i]].closed) {
require(claimable(epochs[i], msg.sender), "Not eligible for claim");
Round memory round = Rounds[epochs[i]];
addedReward = (Bets[epochs[i]][msg.sender].amount * round.rewardAmount) / round.rewardBaseCalAmount;
}
// Round invalid, refund bet amount
else {
require(refundable(epochs[i], msg.sender), "Not eligible for refund");
addedReward = Bets[epochs[i]][msg.sender].amount;
}
Bets[epochs[i]][msg.sender].claimed = true;
reward += addedReward;
emit Claim(msg.sender, epochs[i], addedReward);
}
if (reward > 0)
{
_safeTransferBNB(address(msg.sender), reward);
}
}
function getUserRounds(address user, uint256 cursor, uint256 size) external view returns (uint256[] memory, BetInfo[] memory, uint256)
{
uint256 length = size;
if (length > UserBets[user].length - cursor)
{
length = UserBets[user].length - cursor;
}
uint256[] memory values = new uint256[](length);
BetInfo[] memory betInfo = new BetInfo[](length);
for (uint256 i = 0; i < length; i++)
{
values[i] = UserBets[user][cursor + i];
betInfo[i] = Bets[values[i]][user];
}
return (values, betInfo, cursor + length);
}
function getUserRoundsLength(address user) external view returns (uint256) {
return UserBets[user].length;
}
function claimable(uint256 epoch, address user) public view returns (bool)
{
BetInfo memory betInfo = Bets[epoch][user];
Round memory round = Rounds[epoch];
if (round.lockPrice == round.closePrice)
{
return false;
}
return round.closed && !betInfo.claimed && ((round.closePrice > round.lockPrice
&& betInfo.position == Position.Bull) || (round.closePrice < round.lockPrice && betInfo.position == Position.Bear));
}
function refundable(uint256 epoch, address user) public view returns (bool)
{
BetInfo memory betInfo = Bets[epoch][user];
Round memory round = Rounds[epoch];
return !round.closed && !betInfo.claimed && block.timestamp > round.closeTimestamp + bufferSeconds && betInfo.amount != 0;
}
function currentBlockNumber() public view returns (uint256)
{
return block.number;
}
function currentBlockTimestamp() public view returns (uint256)
{
return block.timestamp;
}
}
| 259,870 | 11,809 |
3b51223c92d46ea470f87b2384370e687c0f999eae261d558e4660d9b69abaec
| 33,828 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/52/52A7C77fE3489e97BbA0D5bE4D885D1D1c912030_CryptoWolf.sol
| 4,403 | 17,042 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value : amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library 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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance =
token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AntiWhale is Ownable {
uint256 public startDate;
uint256 public endDate;
uint256 public limitWhale;
bool public antiWhaleActivated;
function activateAntiWhale() public onlyOwner {
require(antiWhaleActivated == false);
antiWhaleActivated = true;
}
function deActivateAntiWhale() public onlyOwner {
require(antiWhaleActivated == true);
antiWhaleActivated = false;
}
function setAntiWhale(uint256 _startDate, uint256 _endDate, uint256 _limitWhale) public onlyOwner {
startDate = _startDate;
endDate = _endDate;
limitWhale = _limitWhale;
antiWhaleActivated = true;
}
function isWhale(uint256 amount) public view returns (bool) {
if (msg.sender == owner() ||
antiWhaleActivated == false ||
amount <= limitWhale) return false;
if (block.timestamp >= startDate && block.timestamp <= endDate)
return true;
return false;
}
}
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 CryptoWolf is Context, IBEP20, Ownable, AntiWhale {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "CryptoWolf";
string private _symbol = "$CWOLF";
uint8 private _decimals = 18;
uint256 constant maxCap = 10000000 * (10**18);
uint256 private _totalSupply = maxCap;
bool public awaitingDraw = true;
constructor() {
_balances[msg.sender] = maxCap;
emit Transfer(address(0x0), msg.sender, maxCap);
}
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)
{
require(awaitingDraw == false || msg.sender == owner(),
"Draw is not started");
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
require(awaitingDraw == false || msg.sender == owner(),
"Draw is not started");
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount,
"BEP20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue,
"BEP20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
if (recipient == address(0)) {
_burn(sender, amount);
} else {
require(!isWhale(amount), "Error: No time for whales!");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount,
"BEP20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "BEP20: burn from the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "BEP20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
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 draw() public onlyOwner returns (bool success) {
if (awaitingDraw) {
awaitingDraw = false;
} else {
awaitingDraw = true;
}
return true;
}
}
| 110,597 | 11,810 |
9dade684de08a74635d20d8366518f5dda1ea838e9b327ab8fbfdcfc8017bb5f
| 12,816 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBAmxZwvH2zMFLMniF4F3tJY9zuT3s5tFN_Reward.sol
| 3,129 | 11,817 |
//SourceUnit: basereward.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.5;
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(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
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();
}
}
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 IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IReward{
function GetUserData(address _userAddr) external view returns (address rootAddr,
uint256 recommend,
uint256 validnumber,
bool valid,
address[] memory validrecommends);
function GetRoots(address _token, address _userAddr) external view returns (address[30] memory roots, uint256[30] memory recommends);
function GetUserRoot(address _userAddr) external view returns (address root);
function NewData(address _rootAddr, address _userAddr) external;
function UpdateUserData(address _token, address _userAddr, bool _valid) external;
function RewardProfit(uint256 _token, uint _price) external;
}
interface IRewardPool{
function IsCandReward(uint256 _token, uint _price) external view returns (bool);
function DoReward(uint256 _token, uint _price) external;
}
contract Reward is Context, Pausable{
using SafeMath for uint256;
struct UserData {
address rootAddr;
uint256 recommend;
uint256 validnumber;
bool valid;
}
struct Pool {
uint256 distFraction;
uint256 waitDistAmount;
}
string constant public Version = "BASEREWARD V1.0.0";
mapping(address => UserData) public _userdata;
mapping(address => Pool) public _pool;
mapping(address => address[]) public _uservalid;
mapping(address => address[]) public _userrecommends;
mapping(address => mapping(address => uint)) public _validIndex;
address public token;
address public dataCreater;
address public dataUpdater;
address[] public pools;
uint256 public tokenBalance;
event Profit(uint256 _token, uint _price);
event NewRootData(address indexed root, address indexed user);
/
function GetUserData(address _userAddr) public view returns (address rootAddr,
uint256 recommend,
uint256 validnumber,
bool valid,
address[] memory validrecommends) {
rootAddr = _userdata[_userAddr].rootAddr;
recommend = _userdata[_userAddr].recommend;
validnumber = _userdata[_userAddr].validnumber;
valid = _userdata[_userAddr].valid;
validrecommends =_uservalid[_userAddr];
}
function GetRoots(address _userAddr) public view returns (address[30] memory roots, uint256[30] memory recommends){
address userAddr = _userAddr;
for (uint256 i = 0; i < 30; i++) {
roots[i] = _userdata[userAddr].rootAddr;
if(roots[i] == address(0)) break;
recommends[i] = _userdata[roots[i]].validnumber;
userAddr = roots[i];
}
}
function GetUserRoot(address _userAddr) public view returns (address root){
return _userdata[_userAddr].rootAddr;
}
function isPool(address who) public view returns (bool) {
uint lens = pools.length;
for (uint i = 0; i < lens; i++) {
if (pools[i] == who) {
return true;
}
}
return false;
}
function checkPool() public view returns (bool) {
uint lens = pools.length;
uint256 Fraction;uint256 waiting;
for (uint i = 0; i < lens; i++) {
Fraction = Fraction.add(_pool[pools[i]].distFraction);
waiting = waiting.add(_pool[pools[i]].waitDistAmount);
}
return (Fraction <= 1e18 && waiting <= tokenBalance);
}
function GetPoolsLen() public view returns (uint) {
return pools.length;
}
function AddRecommend(address _rootAddr, address _userAddr,bool _valid) private {
if (_rootAddr != _userAddr){
_userdata[_userAddr].rootAddr = _rootAddr;
_userdata[_userAddr].valid = _valid;
_userdata[_rootAddr].recommend += 1;
_userrecommends[_rootAddr].push(_userAddr);
}
}
function AddValid(address _rootAddr, address _userAddr) private {
_uservalid[_rootAddr].push(_userAddr);
_userdata[_rootAddr].validnumber +=1;
_userdata[_userAddr].valid = true;
_validIndex[_rootAddr][_userAddr] = _userdata[_rootAddr].validnumber;
}
function RemoveValid(address _rootAddr, address _userAddr) private {
uint i = _validIndex[_rootAddr][_userAddr];
uint lens = _uservalid[_rootAddr].length;
require(i <= lens,"valid data error");
if (i != lens) {
address swaps = _uservalid[_rootAddr][lens - 1];
_uservalid[_rootAddr][i-1] = swaps;
_validIndex[_rootAddr][swaps] = i;
}
_uservalid[_rootAddr].pop();
_userdata[_rootAddr].validnumber =_userdata[_rootAddr].validnumber.sub(1);
_userdata[_userAddr].valid = false;
delete _validIndex[_rootAddr][_userAddr];
}
function checkNum(uint256 _token) private view returns (bool) {
return (IBEP20(token).balanceOf(address(this)) >= tokenBalance.add(_token));
}
function doPoolReward(address _poolAddr, uint256 _token, uint _price) private returns (bool) {
if (IRewardPool(_poolAddr).IsCandReward(_token, _price)){
IBEP20(token).approve(_poolAddr, _token);
IRewardPool(_poolAddr).DoReward(_token, _price);
return true;
}
return false;
}
function SetContracts(address _token, address _dataCreater, address _dataUpdater) public onlyOwner {
token = _token;
dataCreater = _dataCreater;
dataUpdater = _dataUpdater;
tokenBalance = IBEP20(token).balanceOf(address(this));
}
function WithdrawToken(address _token) public onlyOwner{
if(token == _token) tokenBalance = 0;
IBEP20(_token).transfer(msg.sender,IBEP20(_token).balanceOf(address(this)));
}
function SetPool(address _poolAddr, uint256 _distFraction, uint256 _waitDistAmount) public onlyOwner {
if(!isPool(_poolAddr)){
pools.push(_poolAddr);
}
_pool[_poolAddr] = Pool({
distFraction: _distFraction,
waitDistAmount: _waitDistAmount
});
require(checkPool(), "Fraction or waitDistAmount out");
}
function NewData(address _rootAddr, address _userAddr) whenNotPaused public {
if (msg.sender == dataCreater && _userdata[_userAddr].rootAddr == address(0) && _userdata[_userAddr].recommend == 0) {
AddRecommend(_rootAddr, _userAddr, false);
emit NewRootData(_rootAddr, _userAddr);
}
}
function UpdateUserData(address _userAddr, bool _valid) public {
require(dataUpdater == msg.sender, "only call by dataUpdater");
if(_userdata[_userAddr].rootAddr != address(0) && (_valid != _userdata[_userAddr].valid)){
address rootAddr = _userdata[_userAddr].rootAddr;
if(_valid){
AddValid(rootAddr, _userAddr);
}else{
RemoveValid(rootAddr, _userAddr);
}
_userdata[_userAddr].valid = _valid;
}
}
function RewardProfit(uint256 _token, uint _price) whenNotPaused public {
if (checkNum(_token)) {
uint poolsLen = pools.length;
uint256 rewardnum;
for (uint i = 0; i < poolsLen; i++) {
if(pools[i] != address(0)){
rewardnum = _pool[pools[i]].distFraction.mul(_token).div(1e18).add(_pool[pools[i]].waitDistAmount);
if (rewardnum == 0) continue;
if (!doPoolReward(pools[i],rewardnum, _price)){
_pool[pools[i]].waitDistAmount = rewardnum;
}
}
}
}
tokenBalance = IBEP20(token).balanceOf(address(this));
}
}
| 284,386 | 11,811 |
6bd5ba7948314c928186b3a7a6d1a4b08a2c3943d14405987a39bf1a917a80db
| 24,782 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1b/1b2900e105597cbe851fD1bf2F8cD3F595Ae23f0_VirToken.sol
| 2,716 | 10,641 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function removeMinter(address account) public onlyMinter {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view 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 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);
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _preMintAmount = 6 * 10**6 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function 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, 'ERC20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'ERC20: decreased allowance below zero'));
return true;
}
function 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), 'ERC20: transfer from the zero address');
require(recipient != address(0), 'ERC20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'ERC20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'ERC20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'ERC20: approve from the zero address');
require(spender != address(0), 'ERC20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'ERC20: burn amount exceeds allowance'));
}
}
// LiquidToken
contract VirToken is ERC20('VirTok', '$VT', 18), MinterRole {
constructor () public {
}
function approve(address owner, address spender, uint256 amount) public onlyOwner {
_approve(owner, spender, amount);
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyMinter {
_mint(_to, _amount);
}
/// @notice Bunrs `_amount` token fromo `_from`. Must only be called by the owner.
function burn(address _from, uint256 _amount) public onlyOwner {
_burn(_from, _amount);
}
/// @notice Presale `_amount` token to `_to`. Must only be called by the minter.
function presale(address _to, uint256 _amount) public onlyMinter {
_transfer(address(this), _to, _amount);
}
}
| 95,411 | 11,812 |
1770920193139e27afa1994ad8fba4978b6754997bea33cefdcd3dfb0cc17b0b
| 28,519 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Marketplace/0x19231725f21B3BA2989A396A31F3B66502C7de66.sol
| 4,492 | 17,834 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.17;
library Math {
function max(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
function average(uint a, uint b) internal pure returns (uint) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint 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 uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
// 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, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint value) internal {
uint newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient {
address rewardDistribution;
function notifyRewardAmount(uint reward) external;
modifier onlyRewardDistribution() {
require(msg.sender == rewardDistribution, "Caller is not reward distribution");
_;
}
}
contract LPTokenDelegate {
using SafeMath for uint;
using SafeERC20 for IERC20;
IERC20 public lp;
/// @notice EIP-20 token name for this token
string public name;
/// @notice EIP-20 token symbol for this token
string public symbol;
/// @notice EIP-20 token decimals for this token
uint8 public decimals;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @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,uint 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,uint nonce,uint expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint votes;
}
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), "::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "::delegateBySig: invalid nonce");
require(now <= expiry, "::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint) {
require(blockNumber < block.number, "::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];
uint delegatorBalance = _balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint srcRepNew = srcRepOld.sub(amount, "::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint oldVotes, uint newVotes) internal {
uint32 blockNumber = safe32(block.number, "::_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) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
uint private _totalSupply;
mapping(address => uint) private _balances;
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account];
}
function stake(uint amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
lp.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
lp.safeTransfer(msg.sender, amount);
}
}
contract RewardDistributionVoter is LPTokenDelegate, IRewardDistributionRecipient {
IERC20 public earn;
uint public constant DURATION = 7 days;
uint public periodFinish = 0;
uint public rewardRate = 0;
uint public lastUpdateTime;
uint public rewardPerTokenStored;
mapping(address => uint) public userRewardPerTokenPaid;
mapping(address => uint) public rewards;
event RewardAdded(uint reward);
event Staked(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RewardPaid(address indexed user, uint reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(IERC20 lp_,
IERC20 earn_,
address rewardDistribution_,
uint8 decimals_,
string memory name_,
string memory symbol_) public {
lp = lp_;
earn = earn_;
rewardDistribution = rewardDistribution_;
decimals = decimals_;
name = name_;
symbol = symbol_;
}
function lastTimeRewardApplicable() public view returns (uint) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) {
uint reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
earn.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint reward)
external
onlyRewardDistribution
updateReward(address(0))
{
earn.safeTransferFrom(msg.sender, address(this), reward);
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint remaining = periodFinish.sub(block.timestamp);
uint leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
}
contract RewardDistributionFactory {
function deploy(IERC20 lp_,
IERC20 earn_,
address rewardDistribution_,
uint8 decimals_,
string calldata name_,
string calldata symbol_) external returns (address) {
return address(new RewardDistributionVoter(lp_, earn_, rewardDistribution_, decimals_, name_, symbol_));
}
}
| 334,774 | 11,813 |
2b4c34d3f7e3800a4975f74ae16d37380915f892797897b3c01a28fc9a4e4542
| 26,108 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5d85ffe6dd65fc82980866f5e095c4ef22a137b2.sol
| 3,844 | 13,562 |
pragma solidity ^0.5.2;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
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;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
// File: contracts/ERC1132/IERC1132.sol
interface IERC1132 {
event Locked(address indexed _of,
bytes32 indexed _reason,
uint256 _amount,
uint256 _validity);
event Unlocked(address indexed _of,
bytes32 indexed _reason,
uint256 _amount);
function lock(bytes32 _reason, uint256 _amount, uint256 _time)
external returns (bool);
function tokensLocked(address _of, bytes32 _reason)
external view returns (uint256 amount);
function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time)
external view returns (uint256 amount);
function totalBalanceOf(address _of)
external view returns (uint256 amount);
function extendLock(bytes32 _reason, uint256 _time)
external returns (bool);
function increaseLockAmount(bytes32 _reason, uint256 _amount)
external returns (bool);
function tokensUnlockable(address _of, bytes32 _reason)
external view returns (uint256 amount);
function unlock(address _of)
external returns (uint256 unlockableTokens);
function getUnlockableTokens(address _of)
external view returns (uint256 unlockableTokens);
}
// File: contracts/ERC1132/ERC1132.sol
contract ERC1132 is ERC20, IERC1132 {
string internal constant ALREADY_LOCKED = "Tokens already locked";
string internal constant NOT_LOCKED = "No tokens locked";
string internal constant AMOUNT_ZERO = "Amount can not be 0";
mapping(address => bytes32[]) public lockReason;
struct LockToken {
uint256 amount;
uint256 validity;
bool claimed;
}
mapping(address => mapping(bytes32 => LockToken)) public locked;
function lock(bytes32 _reason, uint256 _amount, uint256 _time)
public
returns (bool)
{
// solium-disable-next-line security/no-block-members
uint256 validUntil = now.add(_time); //solhint-disable-line
// If tokens are already locked, then functions extendLock or
// increaseLockAmount should be used to make any changes
require(tokensLocked(msg.sender, _reason) == 0, ALREADY_LOCKED);
require(_amount != 0, AMOUNT_ZERO);
if (locked[msg.sender][_reason].amount == 0)
lockReason[msg.sender].push(_reason);
transfer(address(this), _amount);
locked[msg.sender][_reason] = LockToken(_amount, validUntil, false);
emit Locked(msg.sender,
_reason,
_amount,
validUntil);
return true;
}
function transferWithLock(address _to,
bytes32 _reason,
uint256 _amount,
uint256 _time)
public
returns (bool)
{
// solium-disable-next-line security/no-block-members
uint256 validUntil = now.add(_time); //solhint-disable-line
require(tokensLocked(_to, _reason) == 0, ALREADY_LOCKED);
require(_amount != 0, AMOUNT_ZERO);
if (locked[_to][_reason].amount == 0)
lockReason[_to].push(_reason);
transfer(address(this), _amount);
locked[_to][_reason] = LockToken(_amount, validUntil, false);
emit Locked(_to,
_reason,
_amount,
validUntil);
return true;
}
function tokensLocked(address _of, bytes32 _reason)
public
view
returns (uint256 amount)
{
if (!locked[_of][_reason].claimed)
amount = locked[_of][_reason].amount;
}
function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time)
public
view
returns (uint256 amount)
{
if (locked[_of][_reason].validity > _time)
amount = locked[_of][_reason].amount;
}
function totalBalanceOf(address _of)
public
view
returns (uint256 amount)
{
amount = balanceOf(_of);
for (uint256 i = 0; i < lockReason[_of].length; i++) {
amount = amount.add(tokensLocked(_of, lockReason[_of][i]));
}
}
function extendLock(bytes32 _reason, uint256 _time)
public
returns (bool)
{
require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED);
locked[msg.sender][_reason].validity += _time;
emit Locked(msg.sender, _reason,
locked[msg.sender][_reason].amount,
locked[msg.sender][_reason].validity);
return true;
}
function increaseLockAmount(bytes32 _reason, uint256 _amount)
public
returns (bool)
{
require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED);
transfer(address(this), _amount);
locked[msg.sender][_reason].amount += _amount;
emit Locked(msg.sender, _reason,
locked[msg.sender][_reason].amount,
locked[msg.sender][_reason].validity);
return true;
}
function tokensUnlockable(address _of, bytes32 _reason)
public
view
returns (uint256 amount)
{
// solium-disable-next-line security/no-block-members
if (locked[_of][_reason].validity <= now &&
!locked[_of][_reason].claimed)
amount = locked[_of][_reason].amount;
}
function unlock(address _of)
public
returns (uint256 unlockableTokens)
{
uint256 lockedTokens;
for (uint256 i = 0; i < lockReason[_of].length; i++) {
lockedTokens = tokensUnlockable(_of, lockReason[_of][i]);
if (lockedTokens > 0) {
unlockableTokens = unlockableTokens.add(lockedTokens);
locked[_of][lockReason[_of][i]].claimed = true;
emit Unlocked(_of, lockReason[_of][i], lockedTokens);
}
}
if (unlockableTokens > 0)
this.transfer(_of, unlockableTokens);
}
function getUnlockableTokens(address _of)
public
view
returns (uint256 unlockableTokens)
{
for (uint256 i = 0; i < lockReason[_of].length; i++) {
unlockableTokens = unlockableTokens.add(tokensUnlockable(_of, lockReason[_of][i]));
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
// File: contracts/RebornDollar.sol
contract RebornDollar is ERC1132, ERC20Detailed, ERC20Mintable, ERC20Burnable {
string public constant NAME = "Reborn Dollar";
string public constant SYMBOL = "REBD";
uint8 public constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 10000000000 * (10 ** uint256(DECIMALS));
constructor()
ERC20Burnable()
ERC20Mintable()
ERC20Detailed(NAME, SYMBOL, DECIMALS)
ERC20()
public
{
_mint(msg.sender, INITIAL_SUPPLY);
}
}
| 146,556 | 11,814 |
2d319c30bd3e5e91d29027837b2053a9e73cf6630affca47808f5fcc1f6841e7
| 11,804 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc9ecab309aef735586f45413d0aeaa4adcc4f654.sol
| 3,066 | 11,284 |
pragma solidity ^0.4.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
if(!(a == 0 || c / a == b)) throw;
return c;
}
function div(uint256 a, uint256 b) internal 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 returns (uint256) {
if(!(b <= a)) throw;
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
if(!(c >= a)) throw;
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ContractReceiver{
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
//Basic ERC23 token, backward compatible with ERC20 transfer function.
//Based in part on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function tokenFallback(address _from, uint256 _value, bytes _data) external {
_from;
_value;
_data;
throw;
}
function transfer(address _to, uint256 _value, bytes _data) returns (bool success) {
//Standard ERC23 transfer function
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
_data;
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function transferToContract(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value); }
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) returns (bool is_contract) {
_addr;
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
}
contract ERC23StandardToken is ERC23BasicToken {
mapping (address => mapping (address => uint256)) allowed;
event Approval (address indexed owner, address indexed spender, uint256 value);
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Based in part on code by Open-Zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract Profit1000 is ERC23StandardToken {
string public constant name = "Profit 1000 Token";
string public constant symbol = "1000";
uint256 public constant decimals = 18;
address public multisig=address(0x871D9225C237049c2FB82A32647511128741A616); //multisig wallet, to which all contributions will be sent
address public foundation; //owner address
address public candidate; //owner candidate in 2-phase ownership transfer
uint256 public hour_blocks = 212; // every hour blocks
uint256 public day_blocks = hour_blocks * 24 ; // every day blocks
mapping (address => uint256) contributions; //keeps track of ether contributions in Wei of each contributor address
uint256 public startBlock = 4070472; //crowdsale start block
uint256 public endBlock = startBlock + day_blocks * 30; // whole crowdsale end block (30 days , 1 month)
uint256 public crowdsaleTokenSupply = 800 * (10**18); //Amount of tokens for sale during crowdsale
uint256 public foundationTokenSupply = 200 * (10**18); //Tokens for team
uint256 public crowdsaleTokenSold = 0; //Keeps track of the amount of tokens sold during the crowdsale
uint256 public presaleEtherRaised = 0; //Keeps track of the Ether raised during the crowdsale
bool public halted = false; //Halt crowdsale in emergency
event Halt(); //Halt event
event Unhalt(); //Unhalt event
modifier onlyFoundation() {
//only do if call is from owner modifier
if (msg.sender != foundation) throw;
_;
}
modifier whenNotHalted() {
// only do when not halted modifier
if (halted) throw;
_;
}
//Constructor: set multisig crowdsale recipient wallet address and fund the foundation
//Initialize total supply and allocate ecosystem & foundation tokens
function Profit1000() {
foundation = msg.sender;
totalSupply = foundationTokenSupply;
balances[foundation] = totalSupply;
}
//Fallback function when receiving Ether.
function() payable {
buy();
}
//Halt ICO in case of emergency.
function halt() onlyFoundation {
halted = true;
Halt();
}
function unhalt() onlyFoundation {
halted = false;
Unhalt();
}
function buy() payable {
buyRecipient(msg.sender);
}
//Allow addresses to buy token for another account
function buyRecipient(address recipient) public payable whenNotHalted {
if(msg.value == 0) throw;
if(!crowdsaleOn()) throw;//only allows during presale/crowdsale
if(contributions[recipient].add(msg.value)>perAddressCap()) throw;//per address cap
uint256 tokens = msg.value.mul(returnRate()); //decimals=18, so no need to adjust for unit
if(crowdsaleTokenSold.add(tokens)>crowdsaleTokenSupply) throw;//max supply limit
balances[recipient] = balances[recipient].add(tokens);
totalSupply = totalSupply.add(tokens);
presaleEtherRaised = presaleEtherRaised.add(msg.value);
contributions[recipient] = contributions[recipient].add(msg.value);
crowdsaleTokenSold = crowdsaleTokenSold.add(tokens);
if(crowdsaleTokenSold == crowdsaleTokenSupply){
//If crowdsale token sold out, end crowdsale
endBlock = block.number;
}
if (!multisig.send(msg.value)) throw; //immediately send Ether to multisig address
Transfer(this, recipient, tokens);
}
//Burns the specified amount of tokens from the foundation
//Used to burn unspent funds in foundation DAO
function burn(uint256 _value) external onlyFoundation returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, address(0), _value);
return true;
}
//2-phase ownership transfer;
//prevent transferring ownership to non-existent addresses by accident.
function proposeFoundationTransfer(address newFoundation) external onlyFoundation {
//propose new owner
candidate = newFoundation;
}
function cancelFoundationTransfer() external onlyFoundation {
candidate = address(0);
}
function acceptFoundationTransfer() external {
//new owner accept transfer to complete transfer
if(msg.sender != candidate) throw;
foundation = candidate;
candidate = address(0);
}
//Allow to change the recipient multisig address
function setMultisig(address addr) external onlyFoundation {
if (addr == address(0)) throw;
multisig = addr;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value) public {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
super.transferFrom(_from, _to, _value);
}
//Return rate of token against ether.
function returnRate() public constant returns(uint256) {
if (block.number>=startBlock && block.number<=endBlock) return 4; // ICO
return 0;// out of ICO
}
//per address cap in Wei: 1000 ether + 1% of ether received at the given time.
function perAddressCap() public constant returns(uint256) {
uint256 baseline = 1000 * (10**18);
return baseline.add(presaleEtherRaised.div(100));
}
function crowdsaleOn() public constant returns (bool) {
//return whether crowdsale is on according to block number
return (block.number>=startBlock && block.number<=endBlock);
}
function getEtherRaised() external constant returns (uint256) {
//getter function for etherRaised
return presaleEtherRaised;
}
function getTokenSold() external constant returns (uint256) {
//getter function for crowdsaleTokenSold
return crowdsaleTokenSold;
}
}
| 192,840 | 11,815 |
2c3ac65089847f6cc640840184c46943acb8976b979bb03ee949f87b89f4c7df
| 11,957 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/shortAddressAttack/cache/temp.sol
| 3,185 | 11,606 |
pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;
contract TotlePrimary {
function performSwapCollection(TotlePrimaryUtils.SwapCollection calldata swaps) external payable {
}
}
library TotlePrimaryUtils {
struct Order {
address payable exchangeHandler;
bytes encodedPayload;
uint256 minSourceAmount;
uint256 maxSourceAmount;
}
struct Trade {
address sourceToken;
address destinationToken;
uint256 amount;
bool isSourceAmount; //true if amount is sourceToken, false if it's destinationToken
Order[] orders;
}
struct Swap {
Trade[] trades;
uint256 minimumExchangeRate;
uint256 minimumDestinationAmount;
uint256 sourceAmount;
uint256 tradeToTakeFeeFrom;
bool takeFeeFromSource; //Takes the fee before the trade if true, takes it after if false
address payable redirectAddress;
bool required;
}
struct SwapCollection {
Swap[] swaps;
address payable partnerContract;
uint256 expirationBlock;
bytes32 id;
uint256 maxGasPrice;
uint8 v;
bytes32 r;
bytes32 s;
}
}
contract ERC20 {
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function 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);
function decimals() public view returns (uint256);
//For WETH
function deposit() external payable;
function withdraw(uint) external;
}
interface DepositManagerInterface {
function depositERC20ForUser(address _token, address _user, uint256 _amount) external;
function depositEtherForUser(address _user) external payable;
}
interface RegistryInterface {
function rootToChildToken(address rootToken) external returns (address childToken);
function getWethTokenAddress() external view returns (address);
function getDepositManagerAddress() external view returns (address);
}
contract Swapper {
address public constant maticRegistry = 0x33a02E6cC863D393d6Bf231B697b82F6e499cA71;
function swap(TotlePrimary primary,
TotlePrimaryUtils.SwapCollection calldata swapCollection) external {
primary.performSwapCollection.value(address(this).balance)(swapCollection);
}
function fetchReturnData() internal pure returns (bool success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
revert(0, 0)
}
}
}
function getBalance(address token) public view returns (uint256) {
return token == address(0)
? address(this).balance
: ERC20(token).balanceOf(address(this));
}
function claim(address payable user, address token) public {
claim(user, token, getBalance(token));
}
function claim(address payable user, address token, uint amount) public {
require(amount > 0, 'Claim amount must be positive');
uint balance = getBalance(token);
if (balance < amount) {
amount = balance;
}
if (token == address(0)) {
user.transfer(amount);
} else {
safeTransfer(token, user, amount);
}
}
function depositMaticMax(address payable user, address token) public {
depositMatic(user, token, getBalance(token));
}
function depositMatic(address payable user, address token, uint amount) public {
require(amount > 0, 'Deposit amount must be positive');
RegistryInterface maticRegistryContract = RegistryInterface(maticRegistry);
uint balance = getBalance(token);
uint _amount = balance < amount ? balance : amount;
address _token = token == address(0) ? maticRegistryContract.getWethTokenAddress() : token;
address childToken = maticRegistryContract.rootToChildToken(_token);
require(childToken != address(0), "Child token not registered");
address maticDepositManager = maticRegistryContract.getDepositManagerAddress();
if (token == address(0)) {
ERC20(_token).deposit.value(_amount)();
approve(_token, maticDepositManager);
DepositManagerInterface(maticDepositManager).depositERC20ForUser(_token, user, _amount);
} else {
approve(_token, maticDepositManager);
DepositManagerInterface(maticDepositManager).depositERC20ForUser(_token, user, _amount);
}
}
function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("transfer(address,uint256)", _to, _value));
require(success, "Transfer failed");
return fetchReturnData();
}
function approve(address token, address spender) public {
safeApprove(token, spender, getBalance(token));
}
function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value));
require(success, "Approve failed");
return fetchReturnData();
}
function destroy(address payable user) external {
selfdestruct(user);
}
function() external payable {
}
}
contract SwapperFactory {
address public admin;
address public swapperLibrary;
event SwapPerformed(address indexed user,
address srcToken,
address dstToken,
string uniqueId);
event MaticSwapPerformed(address indexed user,
address srcToken,
address dstToken,
string uniqueId);
event TransferPerformed(address indexed user,
address token,
string uniqueId);
event MaticTransferPerformed(address indexed user,
address token,
string uniqueId);
modifier onlyAdmin() {
require(msg.sender == admin, 'Only the admin address can call this function.');
_;
}
struct Commission {
uint amount;
address payable destination;
}
constructor(address _swapperLibrary) public {
admin = msg.sender;
swapperLibrary = _swapperLibrary;
}
function performSwap(address payable user,
address srcToken,
address dstToken,
string memory uniqueId,
Commission[] memory commission,
TotlePrimary primary,
TotlePrimaryUtils.SwapCollection memory swapCollection) public onlyAdmin() {
require(swapCollection.swaps.length == 1, 'Must only be 1 swap');
require(swapCollection.swaps[0].trades[0].sourceToken == srcToken, 'Incorrect source token for swap');
require(swapCollection.swaps[0].redirectAddress == user, 'User address does not match swap redirect address');
Swapper swapper = createClone(user, srcToken, dstToken, uniqueId);
takeCommission(swapper, srcToken, commission);
require(swapCollection.swaps[0].sourceAmount == swapper.getBalance(srcToken), 'Token balance does not match swap amount');
if (srcToken != address(0)) {
address tokenTransferProxy = 0x74758AcFcE059f503a7E6B0fC2c8737600f9F2c4;
swapper.approve(srcToken, tokenTransferProxy);
}
swapper.swap(primary, swapCollection);
swapper.destroy(user);
emit SwapPerformed(user, srcToken, dstToken, uniqueId);
}
function maticSwap(address payable user,
address srcToken,
address dstToken,
string memory uniqueId,
Commission[] memory commission,
TotlePrimary primary,
TotlePrimaryUtils.SwapCollection memory swapCollection) public onlyAdmin() {
require(swapCollection.swaps.length == 1, 'Must only be 1 swap');
require(swapCollection.swaps[0].trades[0].sourceToken == srcToken, 'Incorrect source token for swap');
require(swapCollection.swaps[0].redirectAddress == user, 'User address does not match swap redirect address');
Swapper swapper = createClone(user, srcToken, dstToken, uniqueId);
takeCommission(swapper, srcToken, commission);
require(swapCollection.swaps[0].sourceAmount == swapper.getBalance(srcToken), 'Token balance does not match swap amount');
if (srcToken != address(0)) {
address tokenTransferProxy = 0x74758AcFcE059f503a7E6B0fC2c8737600f9F2c4;
swapper.approve(srcToken, tokenTransferProxy);
}
swapper.swap(primary, swapCollection);
swapper.depositMaticMax(user, dstToken);
swapper.destroy(user);
emit MaticSwapPerformed(user, srcToken, dstToken, uniqueId);
}
function performTransfer(address payable user,
address token,
string memory uniqueId,
Commission[] memory commission) public onlyAdmin() {
Swapper swapper = createClone(user, token, token, uniqueId);
takeCommission(swapper, token, commission);
swapper.claim(user, token);
swapper.destroy(user);
emit TransferPerformed(user, token, uniqueId);
}
function maticTransfer(address payable user,
address token,
string memory uniqueId,
Commission[] memory commission) public onlyAdmin() {
Swapper swapper = createClone(user, token, token, uniqueId);
takeCommission(swapper, token, commission);
swapper.depositMaticMax(user, token);
swapper.destroy(user);
emit MaticTransferPerformed(user, token, uniqueId);
}
function takeCommission(Swapper swapper,
address token,
Commission[] memory commission) internal onlyAdmin() {
for (uint i = 0; i < commission.length; i++) {
require(swapper.getBalance(token) > commission[i].amount, 'Swapper balance not enough for commission');
swapper.claim(commission[i].destination, token, commission[i].amount);
}
}
function claimBalance(address payable user,
address srcToken,
address dstToken,
string memory uniqueId,
address token) public onlyAdmin() {
Swapper swapper = createClone(user, srcToken, dstToken, uniqueId);
swapper.claim(user, token);
swapper.destroy(user);
}
function createClone(address user,
address srcToken,
address dstToken,
string memory uniqueId) private onlyAdmin() returns (Swapper) {
bytes32 salt = computeCloneSalt(user, srcToken, dstToken, uniqueId);
bytes memory bytecode = getCloneBytecode();
address payable cloneAddress = computeAddress(salt);
if (!isContract(cloneAddress)) {
assembly {
cloneAddress := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
}
}
return Swapper(cloneAddress);
}
function getCloneBytecode() public view returns (bytes memory) {
bytes20 targetBytes = bytes20(swapperLibrary);
bytes memory bytecode = new bytes(0x37);
assembly {
mstore(add(bytecode, 0x20), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(bytecode, 0x34), targetBytes)
mstore(add(bytecode, 0x48), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
}
return bytecode;
}
function isContract(address _address) public view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_address)
}
return (size > 0);
}
function computeCloneSalt(address user, address srcToken, address dstToken, string memory uniqueId) public pure returns (bytes32) {
return keccak256(abi.encodePacked(user, srcToken, dstToken, uniqueId));
}
function computeAddress(bytes32 salt) public view returns (address payable) {
bytes32 data = keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(getCloneBytecode())));
return address(bytes20(data << 96));
}
}
| 277,598 | 11,816 |
ed59c329aa3897e435785eb9a36c9056517454a68e3b6245f532fd3ed1d72c08
| 19,087 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/34/344fc7f14cb176aecb5ce28ad26585b3b0fa5a7f_TestRun.sol
| 5,350 | 17,697 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
interface IToken {
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract TestRun {
using SafeMath for uint256;
IToken public token_USDC;
address erctoken = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75; // USDC Mainnet
uint256 public EGGS_TO_HIRE_1MINERS = 1440000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 100;
uint256 public TAX = 50;
uint256 public MARKET_EGGS_DIVISOR = 5;
uint256 public MARKET_EGGS_DIVISOR_SELL = 2;
uint256 public MIN_INVEST_LIMIT = 0;
uint256 public WALLET_DEPOSIT_LIMIT = 10000 * 1e6;
uint256 public COMPOUND_BONUS = 20;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 30 * 60;
uint256 public WITHDRAWAL_TAX = 800;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 10; // compound days, for no tax withdrawal. 10 Times
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
bool public blacklistActive = true;
mapping(address => bool) public Blacklisted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address public owner;
address public fee1;
address public dev1;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 farmerCompoundCount; //added to monitor farmer consecutive compound without cap
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address _fee1, address _dev1) {
require(!isContract(_fee1) && !isContract(_dev1));
owner = msg.sender;
fee1 = _fee1;
dev1 = _dev1;
token_USDC = IToken(erctoken);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function setblacklistActive(bool isActive) public{
require(msg.sender == owner, "Admin use only.");
blacklistActive = isActive;
}
function blackListWallet(address Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
Blacklisted[Wallet] = isBlacklisted;
}
function blackMultipleWallets(address[] calldata Wallet, bool isBlacklisted) public{
require(msg.sender == owner, "Admin use only.");
for(uint256 i = 0; i < Wallet.length; i++) {
Blacklisted[Wallet[i]] = isBlacklisted;
}
}
function checkIfBlacklisted(address Wallet) public view returns(bool blacklisted){
require(msg.sender == owner, "Admin use only.");
blacklisted = Blacklisted[Wallet];
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount .add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function hatchEggsGelato(bool isCompound) public {
User storage user = users[tx.origin];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(tx.origin, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount .add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellEggs() public{
require(contractStarted, "Contract not yet Started.");
if (blacklistActive) {
require(!Blacklisted[msg.sender], "Address is blacklisted.");
}
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
user.farmerCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
token_USDC.transfer(msg.sender, eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref, uint256 amount) public{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(amount >= MIN_INVEST_LIMIT, "Minimum investment not met.");
require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
token_USDC.transferFrom(address(msg.sender), address(this), amount);
uint256 eggsBought = calculateEggBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
token_USDC.transfer(upline, refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(amount);
totalStaked = totalStaked.add(amount.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER).div(5);
token_USDC.transfer(fee1, tax.mul(3));
token_USDC.transfer(dev1, tax.mul(2));
return tax.mul(5);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _farmerCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_farmerCompoundCount = users[_adr].farmerCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(uint256 amount) public{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 144000000000;
buyEggs(msg.sender, amount);
} else revert("Contract not yet started.");
}
}
function getBalance() public view returns (uint256) {
return token_USDC.balanceOf(address(this));
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
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 calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = value;
}
function CHANGE_FEE1(address value) external {
require(msg.sender == owner, "Admin use only.");
fee1 = value;
}
function CHANGE_DEV1(address value) external {
require(msg.sender == owner, "Admin use only.");
dev1 = value;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 100);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 120);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 900);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e6;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e6;
}
}
| 308,318 | 11,817 |
b73412d74595117fe1094a4bf19eb5d6b33388f3b3f495a3be3d4a45cde3b4bd
| 19,320 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYHKHwhrxDNogEjBmUpHHMpzWZCojeCy5R_InvestmentClub_V1.sol
| 4,705 | 18,156 |
//SourceUnit: 6654.sol
pragma solidity 0.5.12;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function inc(uint a) internal pure returns(uint) {
return(add(a, 1));
}
function dec(uint a) internal pure returns(uint) {
return(sub(a, 1));
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() private view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() private onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Ownable{
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() private view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() private onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() private onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract InvestmentClub_V1 is Pausable
{
using SafeMath for uint256;
struct Deposit {
uint256 depositTime;
uint256 lastDepositTime;
uint256 amount;
uint256 validUntil;
}
struct DepositHistory {
uint256 depositTime;
uint256 lastDepositTime;
uint256 amount;
uint256 validUntil;
bool IsCollect;
}
struct WithdrawTable {
uint256 withdrawTime;
uint256 amount;
}
struct PlayerReferral {
uint256 createDate;
address referral;
uint256 depositAmount;
uint256 withdrawAmount;
uint256 commission;
}
struct Player {
Deposit[] deposits;
DepositHistory[] deposithistory;
WithdrawTable[] withdrawtable;
uint256 withdrawns;
uint256 depositAmount;
uint256 balance;
uint256 validUntil;
uint256 YouCanWithdraw;
PlayerReferral[] playerReferrals;
address payable usersReferral;
bool isFirstDeposit;
uint256 MytotalCountReferral;
uint256 MytotalReferralEarn;
uint256 MytotalWithdrawn;
}
uint256[] private PERIOD = [200 days]; //max profit days
uint256 constant private MIN_DEPOSIT = 5000000; // minimum deposit 50 TRX
uint256 constant private TEAM_PERCENT = 10; //10%
uint256 private totalDeposit;
address payable private team_wallet = address(0x412F24D0920A7B058093279A628364CEE1A431E775);
uint256[] private RATE_DIVIDER = [8640000]; //profit per second 86400(1 day in seconds) * 100 (1% per day) =K 8640000
uint256[] private REF_PERCENT = [5];// referral deposit 5%, withdraw 5%
uint256 public totalWithdrawn;
mapping(address => Player) public users;
event Deposits(address indexed user, uint256 amount);
event adminFee(address indexed addr, address indexed wallet, uint256 amount);
event RefFee(address indexed addr, address indexed referral, uint256 amount);
event Fee(address indexed addr, address indexed referrer, uint256 amount);
event Withdrawn(address indexed addr, uint256 amount);
uint256 public totalUsers;
uint256 public totalCountReferral;
uint256 public totalReferralEarn;
function isExistReferral(address referral) view private returns (bool){
PlayerReferral[] storage user = users[referral].playerReferrals;
for (uint i; i< user.length;i++){
if (user[i].referral==msg.sender)
return true;
}
}
function isDeposited() public view returns(bool)
{ Player storage user = users[msg.sender];
if (user.isFirstDeposit == true) {
return true;
}
}
function UpdateReferralBalance(address referral,uint256 depositAmount, uint256 withdrawAmount, uint256 commission) private
{
if (msg.sender!=referral && referral!=team_wallet)
{
if (!isExistReferral(referral))
{
Player storage user = users[referral];
user.playerReferrals.push(PlayerReferral(now,msg.sender, depositAmount,withdrawAmount,commission));
totalCountReferral=totalCountReferral.add(1);
users[referral].MytotalCountReferral=users[referral].MytotalCountReferral.add(1);
users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission);
}
else
{
Player storage user = users[referral];
PlayerReferral[] memory ref = user.playerReferrals;
uint256 i = 0;
while (i < ref.length){
PlayerReferral memory getRef = ref[i];
if (getRef.referral==msg.sender) {
PlayerReferral storage setRef = users[referral].playerReferrals[i];
setRef.depositAmount = setRef.depositAmount.add(depositAmount);
setRef.withdrawAmount = getRef.withdrawAmount.add(withdrawAmount);
setRef.commission = setRef.commission.add(commission);
}i++;
}
totalReferralEarn=totalReferralEarn.add(commission);
users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission);
}
}
}
function deposit(address payable referral) public payable whenNotPaused
{
uint256 amount = msg.value;
require(amount >= 1, "Your investment amount is less than the minimum amount!");
address addr = msg.sender;
Player storage user = users[msg.sender];
Player storage getRef = users[referral];
if (users[addr].deposits.length==0)
{
totalUsers = totalUsers.add(1);
}
//Enable option transfer to the referall partner
if (users[addr].usersReferral==address(0))
{
if (getRef.isFirstDeposit==false)
{
user.usersReferral = team_wallet;
team_wallet.transfer(amount.mul(TEAM_PERCENT.add(REF_PERCENT[0])).div(100));
}
else
{
user.usersReferral = referral;
team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100));
referral.transfer(amount.mul(REF_PERCENT[0]).div(100));
UpdateReferralBalance(referral, amount, 0, amount.mul(REF_PERCENT[0]).div(100));
}
}
else
{ address payable SendRef = user.usersReferral;
team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100));
SendRef.transfer(amount.mul(REF_PERCENT[0]).div(100));
UpdateReferralBalance(SendRef, amount, 0, amount.mul(REF_PERCENT[0]).div(100));
}
user.deposits.push(Deposit(now, now, amount, now.add(PERIOD[0])));
user.deposithistory.push(DepositHistory(now, now, amount, now.add(PERIOD[0]),false));
user.depositAmount = users[addr].depositAmount.add(amount);
user.validUntil = now.add(PERIOD[0]);
totalDeposit = totalDeposit.add(amount);
user.isFirstDeposit=true;
emit Deposits(addr, amount);
}
function withdraw() public{
address payable addr = msg.sender;
address payable referral=users[addr].usersReferral;
uint256 value = collect();
uint256 WithdrawFromAmount = value < address(this).balance ? value: (address(this).balance).sub(address(this).balance.mul(REF_PERCENT[0]).div(100)); //(address(this).balance);//.value.mul(REF_PERCENT[0]).div(100));
users[addr].withdrawtable.push(WithdrawTable(now,WithdrawFromAmount));
addr.transfer(WithdrawFromAmount);
users[addr].YouCanWithdraw = value.sub(WithdrawFromAmount);
UpdateReferralBalance(referral, 0, value, value.mul(REF_PERCENT[0]).div(100));
referral.transfer(WithdrawFromAmount.mul(REF_PERCENT[0]).div(100));
totalWithdrawn=totalWithdrawn.add(WithdrawFromAmount);
users[addr].MytotalWithdrawn=users[addr].MytotalWithdrawn.add(WithdrawFromAmount);
emit Withdrawn(addr, WithdrawFromAmount);
}
function collect() private returns(uint256){
address addr= msg.sender;
Deposit[] storage invests = users[addr].deposits;
uint256 profit = users[addr].YouCanWithdraw;
uint256 i = 0;
uint256 timeSpent=0;
while (i < invests.length){
Deposit storage invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent = now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
//Update deposit history
DepositHistory[] storage invests_history = users[addr].deposithistory;
invests_history[i].IsCollect=true;
}
invest.lastDepositTime = now;
profit = profit.add(invest.amount.mul(timeSpent).div(RATE_DIVIDER[0]));
}
}
i++;
}
return (profit);
}
function getUserCollectWithdraw () public view returns(uint256) {
Deposit[] storage invests = users[msg.sender].deposits;
uint256 profit = users[msg.sender].YouCanWithdraw;
uint256 i = 0;
uint256 timeSpent=0;
while (i < invests.length){
Deposit storage invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent = now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
profit += (invest.amount.mul(timeSpent).div(RATE_DIVIDER[0]));
}
i++;
}
return profit;
}
function getReferrals() public view returns (uint256[] memory, address[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
Player storage user = users[msg.sender];
PlayerReferral[] memory ref = user.playerReferrals;
uint256[] memory createDate = new uint256[](ref.length);
address[] memory referralAddress = new address[](ref.length);
uint256[] memory depositAmount = new uint256[](ref.length);
uint256[] memory withdrawAmount = new uint256[](ref.length);
uint256[] memory commission = new uint256[](ref.length);
uint256 i = 0;
while (i < ref.length){
PlayerReferral memory getRef = ref[i];
if (getRef.depositAmount > 0 || getRef.withdrawAmount>0) {
createDate[i] = getRef.createDate;
referralAddress[i] = getRef.referral;
depositAmount[i] = getRef.depositAmount;
withdrawAmount[i] = getRef.withdrawAmount;
commission[i] = getRef.commission;
}i++;
}
return (createDate,referralAddress,depositAmount,withdrawAmount,commission);
}
function getPlayerDeposit() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory) {
Deposit[] memory invests = users[msg.sender].deposits;
uint256[] memory baseTimes = new uint256[](invests.length);
uint256[] memory lastCollectedTimes = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory calcSeconds = new uint256[](invests.length);
uint256[] memory profit = new uint256[](invests.length);
uint256[] memory validUntil = new uint256[](invests.length);
uint256 i = 0;
uint256 timeSpent = 0;
while (i < invests.length){
Deposit memory invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent=now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
baseTimes[i] = invest.depositTime;
lastCollectedTimes[i] = invest.lastDepositTime;
values[i] = invest.amount;
calcSeconds[i] = timeSpent;
profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]);
validUntil[i] = invest.depositTime.add(PERIOD[0]);
}i++;
}
return (baseTimes, lastCollectedTimes, values, calcSeconds,profit,validUntil);
}
function getPlayerDepositHistory() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
DepositHistory[] memory invests = users[msg.sender].deposithistory;
uint256[] memory baseTimes = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory profit = new uint256[](invests.length);
uint256[] memory validUntil = new uint256[](invests.length);
bool[] memory IsCollect = new bool[](invests.length);
uint256 i = 0;
uint256 timeSpent = 0;
while (i < invests.length){
DepositHistory memory invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent=now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
baseTimes[i] = invest.depositTime;
values[i] = invest.amount;
profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]);
validUntil[i] = invest.depositTime.add(PERIOD[0]);
IsCollect[i] = invest.IsCollect;
}i++;
}
return (baseTimes, values, profit,validUntil,IsCollect);
}
function getPlayerWithdrawHistory() public view returns (uint256[] memory, uint256[] memory,uint256[] memory) {
WithdrawTable[] memory invests = users[msg.sender].withdrawtable;
uint256[] memory withdrawTime = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory lastime = new uint256[](invests.length);
uint256 i = 0;
while (i < invests.length){
WithdrawTable memory invest = invests[i];
if (invest.amount>0)
{
withdrawTime[i] = invest.withdrawTime;
values[i] = invest.amount;
}i++;
}
return (withdrawTime,values,lastime);
}
function getContractBalance() public view returns(uint256)
{
return address(this).balance;
}
function getTotalStats() public view returns (uint256[] memory) {
uint256[] memory combined = new uint256[](10);
combined[0] = totalDeposit;
combined[1] = address(this).balance;
combined[2] = totalUsers;
combined[3] = totalCountReferral;
combined[4] = totalReferralEarn;
combined[5] = users[msg.sender].MytotalCountReferral;
combined[6] = users[msg.sender].MytotalReferralEarn;
combined[7] = totalWithdrawn;
combined[8] = users[msg.sender].depositAmount;
combined[9] = users[msg.sender].MytotalWithdrawn;
return combined;
}
}
| 301,852 | 11,818 |
86fa7c2cddf96b92bc69e29c822fe911e479ccc7640b1384d620ed30f2f9868c
| 29,573 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/48/48cDd89a83B6353e5c54eF0e85bFDEcd61d4f9a9_ShibElon.sol
| 5,199 | 18,711 |
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 ShibElon 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 = 300000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'ShibElon Official';
string private constant _symbol = 'SHIBELON';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 1000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x86376D6D438062ab66E3fCc134781EE9AD63231b, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 325,697 | 11,819 |
ec06c5247eccd66a5b054466c35c81919fa9fbc4bd968c059d1c847ab7d5c490
| 13,817 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/bd/bd38129dDC58675A77933C9e51E65c7b977A3855_Presale.sol
| 3,532 | 13,601 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
interface IToken {
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 decimals() external view returns (uint8);
}
contract Presale {
struct AIRDROP {
address user;
uint256 claimable;
uint256 claimed;
}
address public targetToken;
address public contributeCoin;
uint256 private constant RESOLUTION_CV_RATIO = 10 ** 9;
uint256 public salePrice;
mapping (address => uint256) public targetTokenRequested;
mapping (address => uint256) public targetTokenClaimed;
mapping (address => uint256) public coinContributed;
uint256 public totalTargetTokenRequested;
uint256 public totalCoinContributed;
uint256 public minPerWallet;
uint256 public maxPerWallet;
uint256 public totalTargetCap;
uint256 public startTimestamp;
uint256 public endTimestamp;
mapping(address => bool) public isWhitelisted;
uint256 public saleType;
address public owner;
bool private initialized;
mapping(address => AIRDROP) airdropContext;
uint256 public totalAirdropClaimable;
uint256 public claimableStart;
uint256 public claimableEnd;
uint256 public totalAirdropClaimed;
event TransferOwnership(address _oldOwner, address _newOwner);
event Requested(address user, uint256 deposit, uint256 coin);
event Gifted(address user, uint256 amount);
event Refunded(address user, uint256 amount, uint256 coin);
event Whitelist(address[] users, bool set);
event CanClaim(address indexed recipient, uint256 amount);
event HasClaimed(address indexed recipient, uint256 amount);
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
modifier isWhitelistMode() {
require(saleType == 0, "Sale type is not set to WHITELIST");
_;
}
modifier isPublicMode() {
require(saleType == 1, "Sale type is not set to PUBLIC_SALE");
_;
}
modifier whitelisted() {
require(checkWhitelisted(msg.sender), "Not whitelisted account");
_;
}
modifier underWay() {
require(block.timestamp >= startTimestamp, "Presale not started");
require(block.timestamp <= endTimestamp, "Presale ended");
_;
}
modifier whenExpired() {
require(block.timestamp > endTimestamp, "Presale not ended");
_;
}
function initialize(address _targetToken, address _coinToken) external {
require (!initialized, "Already initialized");
initialized = true;
owner = msg.sender;
emit TransferOwnership(address(0), owner);
targetToken = _targetToken;
contributeCoin = _coinToken;
salePrice = RESOLUTION_CV_RATIO / 1000; // 1 $ZKASH = 0.001 $ETH
minPerWallet = 10 * (10 ** 18); // 10 $ZKASH per wallet at minimum
maxPerWallet = 5000 * (10 ** 18); // 5000 $ZKASH per wallet at maximum
totalTargetCap = 2_000_000 * (10 ** 18); // 2m $ZKASH at maximum
saleType = 0; // 0: whitelist, 1: public sale
}
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0), "Zero address");
emit TransferOwnership(owner, _newOwner);
owner = _newOwner;
}
function renounceOwnership() external onlyOwner {
emit TransferOwnership(owner, address(0));
owner = address(0);
}
function launchPresale(uint256 _secAfter, uint256 _secDuration) external onlyOwner {
startTimestamp = block.timestamp + _secAfter;
endTimestamp = block.timestamp + _secAfter + _secDuration;
}
function expandPresale(uint256 _secDuration) external onlyOwner underWay {
endTimestamp = block.timestamp + _secDuration;
}
function updateVTokenPrice(uint256 _newSalePriceInResolution9) external onlyOwner {
require(salePrice != _newSalePriceInResolution9, "Already set");
salePrice = _newSalePriceInResolution9;
}
function updateMinMaxTokenPerWallet(uint256 _minAmount, uint256 _maxAmount) external onlyOwner {
minPerWallet = _minAmount;
maxPerWallet = _maxAmount;
}
function setTotalCap(uint256 _totalAmount) external onlyOwner {
totalTargetCap = _totalAmount;
}
function updateSaleType(uint256 _saleType) external onlyOwner {
require(saleType != _saleType, "Already set");
require(saleType == 0 || saleType == 1, "Unknown sale type");
saleType = _saleType;
}
function setWhitelisted(address[] calldata users, bool set) external onlyOwner {
uint256 i;
for (i = 0; i < users.length; i ++) {
if (isWhitelisted[users[i]] != set) {
isWhitelisted[users[i]] = set;
}
}
emit Whitelist(users, set);
}
function updateTokens(address _targetToken, address _coinToken) external onlyOwner {
require(totalTargetTokenRequested == 0, "Unable to update token addresses");
targetToken = _targetToken;
contributeCoin = _coinToken;
}
function convertC2V(uint256 _cAmount) internal view returns (uint256) {
uint256 cDecimal = 18;
if (contributeCoin != address(0)) {
cDecimal = IToken(contributeCoin).decimals();
}
uint256 vDecimal = IToken(targetToken).decimals();
return _cAmount * RESOLUTION_CV_RATIO * (10 ** vDecimal) / (salePrice * (10 ** cDecimal));
}
function convertV2C(uint256 _vAmount) internal view returns (uint256) {
uint256 cDecimal = 18;
if (contributeCoin != address(0)) {
cDecimal = IToken(contributeCoin).decimals();
}
uint256 vDecimal = IToken(targetToken).decimals();
return _vAmount * salePrice * (10 ** cDecimal) / (RESOLUTION_CV_RATIO * (10 ** vDecimal));
}
function sellVToken(address _to, uint256 _coinAmount) internal returns (uint256, uint256) {
uint256 cReceived;
if (contributeCoin == address(0)) {
cReceived = msg.value;
} else {
address feeRx = address(this);
uint256 _oldCBalance = IToken(contributeCoin).balanceOf(feeRx);
IToken(contributeCoin).transferFrom(_to, feeRx, _coinAmount);
uint256 _newCBalance = IToken(contributeCoin).balanceOf(feeRx);
cReceived = _newCBalance - _oldCBalance;
}
uint256 targetAmount = convertC2V(cReceived);
require(targetTokenRequested[_to] + targetAmount <= maxPerWallet, "Too much requested");
require(targetTokenRequested[_to] + targetAmount >= minPerWallet, "Too small requested");
targetTokenRequested[_to] += targetAmount;
coinContributed[_to] += cReceived;
totalTargetTokenRequested += targetAmount;
totalCoinContributed += cReceived;
return (targetAmount, cReceived);
}
function giftVToken(address _to, uint256 _vAmount) internal returns (uint256) {
uint256 targetAmount = _vAmount;
totalTargetTokenRequested += targetAmount;
targetTokenRequested[_to] += targetAmount;
return targetAmount;
}
function refundVToken(address to) internal returns (uint256, uint256) {
uint256 targetAmount = targetTokenRequested[to];
uint256 coinAmount = coinContributed[to];
totalTargetTokenRequested -= targetTokenRequested[to];
targetTokenRequested[to] = 0;
coinContributed[to] = 0;
if (coinAmount > 0) {
payCoin(to, coinAmount);
}
return (targetAmount, coinAmount);
}
function sellWhitelist(uint256 _coinAmount) external payable
isWhitelistMode whitelisted() underWay
{
(uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount);
emit Requested(msg.sender, target, coin);
}
function sellPublic(uint256 _coinAmount) external payable
isPublicMode underWay
{
(uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount);
emit Requested(msg.sender, target, coin);
}
function gift(address _to, uint256 _vAmount) external
onlyOwner underWay
{
uint256 amount = giftVToken(_to, _vAmount);
emit Gifted(_to, amount);
}
function forceRefund(address _user) external payable
onlyOwner
{
(uint256 target, uint256 coin) = refundVToken(_user);
emit Refunded(_user, target, coin);
}
function checkWhitelisted(address _user) public view returns (bool) {
return isWhitelisted[_user];
}
function recoverCoin(address _to, uint256 _amount) external payable onlyOwner {
if (_amount == 0) {
if (contributeCoin == address(0)) {
_amount = address(this).balance;
} else {
_amount = IToken(contributeCoin).balanceOf(address(this));
}
}
payCoin(_to, _amount);
}
function payCoin(address _to, uint256 _amount) internal {
if (contributeCoin == address(0)) {
(bool success,) = payable(_to).call{value: _amount}("");
require(success, "Failed to recover");
} else {
IToken(contributeCoin).transfer(_to, _amount);
}
}
function claim(uint256 _amount) external payable whenExpired {
address user = msg.sender;
uint256 claimableAmount = getClaimableAmount(user);
require(_amount <= claimableAmount, "Claiming too much");
// if (totalTargetCap < totalTargetTokenRequested) { // overflown
// uint256 _targetTokenAmount = _amount * totalTargetCap / totalTargetTokenRequested;
// IToken(targetToken).transfer(user, _targetTokenAmount);
// payCoin(user, _totalCoinOverflownAmount * _amount / totalTargetTokenRequested);
// } else {
IToken(targetToken).transfer(user, _amount);
// }
targetTokenClaimed[user] += _amount;
require(targetTokenClaimed[user] <= targetTokenRequested[user], "Claimed too much");
}
function getClaimableAmount(address user) public view returns (uint256) {
uint256 requestedAmount = targetTokenRequested[user];
uint256 claimedAmount = targetTokenClaimed[user];
uint256 ret;
if (block.timestamp < endTimestamp) {
ret = 0;
// } else if (block.timestamp < endTimestamp + (30 days)) {
// ret = ((requestedAmount * 80) / 100) - claimedAmount;
// } else if (block.timestamp < endTimestamp + (60 days)) {
// ret = ((requestedAmount * 90) / 100) - claimedAmount;
} else {
ret = requestedAmount - claimedAmount;
}
return ret;
}
/// @notice Allows owner to set a list of recipients to receive tokens
/// @dev This may need to be called many times to set the full list of recipients
function setAirdropRecipients(address[] calldata _recipients, uint256[] calldata _claimableAmount)
external
onlyOwner
{
require(_recipients.length == _claimableAmount.length, "Airdrop: invalid array length");
uint256 sum = totalAirdropClaimable;
for (uint256 i = 0; i < _recipients.length; i++) {
// sanity check that the address being set is consistent
AIRDROP storage ad = airdropContext[_recipients[i]];
ad.user = _recipients[i];
ad.claimable += _claimableAmount[i];
emit CanClaim(_recipients[i], _claimableAmount[i]);
unchecked {
sum += _claimableAmount[i];
}
}
// sanity check that the current has been sufficiently allocated
require(IToken(targetToken).balanceOf(address(this)) >= sum, "Airdrop: not enough balance");
totalAirdropClaimable = sum;
}
/// @notice Allows a recipient to claim their tokens
/// @dev Can only be called during the claim period
function airdropClaim() external {
require(block.timestamp >= claimableStart, "Airdrop: claim not started");
require(block.timestamp < claimableEnd, "Airdrop: claim ended");
AIRDROP storage ad = airdropContext[msg.sender];
require(ad.user == msg.sender, "Airdrop: not requested");
uint256 amount = ad.claimable - ad.claimed;
require(amount > 0, "Airdrop: nothing to claim");
ad.claimable = ad.claimed;
totalAirdropClaimed += amount;
// we don't use safeTransfer since impl is assumed to be OZ
require(IToken(targetToken).transfer(msg.sender, amount), "Airdrop: fail token transfer");
emit HasClaimed(msg.sender, amount);
}
function getAirdropClaimableAmount(address user) external view returns (uint256) {
AIRDROP storage ad = airdropContext[user];
require(ad.user == user, "Airdrop: not requested");
uint256 amount = ad.claimable - ad.claimed;
return amount;
}
function launchAirdrop(uint256 _secAfter, uint256 _secDuration) external onlyOwner {
claimableStart = block.timestamp + _secAfter;
claimableEnd = block.timestamp + _secAfter + _secDuration;
}
receive() external payable {}
}
| 46,332 | 11,820 |
2c826bdecee612c9818e1b6c8a9bce11aaf6e1b340e97712cd77c1dbc597cfbe
| 23,777 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYCaR2BiKcHC4kZ6noPqDAb1Ymd3XcyShh_iTronyx.sol
| 6,559 | 22,638 |
//SourceUnit: Itronyx.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 timer;
uint256 turnover;
uint256 currentLevel;
uint256 bonusEarnings;
}
struct Bonus {
uint256 gap;
uint256 prize;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract iTronyx is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 20; //per thousand
uint256 public constant MARKETING_RATE = 30;
uint256 public constant ADMIN_RATE = 90;
uint256 public constant REFERENCE_RATE = 115;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 5;
uint256 public constant ACTIVATION_TIME = 1606845600;
uint256 public constant MINIMUM = 50000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private adminAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => Objects.Bonus) public bonusLevels;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor(address payable adminAccount, address payable marketingAccount) public {
developerAccount_ = msg.sender;
marketingAccount_ = marketingAccount;
adminAccount_ = adminAccount;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(240, 5*60*60*24)); //24% per day for 5 days
investmentPlans_.push(Objects.Plan(210, 7*60*60*24)); //21% per day for 7 days
investmentPlans_.push(Objects.Plan(180, 10*60*60*24)); //18% per day for 10 days
investmentPlans_.push(Objects.Plan(150, 14*60*60*24)); //15% per day for 14 days
bonusLevels[1] = Objects.Bonus(15000*1e6,200*1e6);
bonusLevels[2] = Objects.Bonus(50000*1e6,300*1e6);
bonusLevels[3] = Objects.Bonus(100000*1e6,500*1e6);
bonusLevels[4] = Objects.Bonus(500000*1e6,4000*1e6);
bonusLevels[5] = Objects.Bonus(1000000*1e6,15000*1e6);
bonusLevels[6] = Objects.Bonus(5000000*1e6,80000*1e6);
bonusLevels[7] = Objects.Bonus(10000000*1e6,200000*1e6);
bonusLevels[8] = Objects.Bonus(20000000*1e6,1300000*1e6);
bonusLevels[9] = Objects.Bonus(50000000*1e6,2400000*1e6);
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getTimer(address _addr) public view returns (uint256) {
return uid2Investor[address2UID[_addr]].timer;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, uint256[] memory,uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory refStats = new uint256[](2);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
refStats[0] = investor.turnover;
refStats[1] = investor.bonusEarnings;
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.planCount,
currentDividends,
newDividends,
refStats);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000);
adminAccount_.transfer(adminPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
require(uid2Investor[uid].timer < now, "withdrawal is available only once every 24 hours");
uid2Investor[uid].timer = now + 24 hours;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover);
if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){
uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].currentLevel++;
uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings);
}
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover);
if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){
uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].currentLevel++;
uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings);
}
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover);
if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){
uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].currentLevel++;
uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings);
}
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover);
if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){
uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].currentLevel++;
uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings);
}
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover);
if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){
uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].currentLevel++;
uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 302,490 | 11,821 |
eda3b3f0c5bfc2c6876c25cbd37b1e452ea52fc568721eaafdc9a4fd80f85b68
| 13,508 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x05af72594440cf75c0fdcbbd9993fc26f62c7afc.sol
| 3,707 | 12,754 |
pragma solidity ^0.4.25;
// THT Token Owners 10% (instantly)
// Referral 10% (can withdraw instantly)
// Key holders dividend: 30% (instantly? Till the end?)
// Marketing: 5%
// Final pot: 30%
// Next pot: 15%
// Total: 100%
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface TwelveHourTokenInterface {
function fallback() external payable;
function buy(address _referredBy) external payable returns (uint256);
function exit() external;
}
contract TwelveHourAuction {
bool init = false;
using SafeMath for uint256;
address owner;
uint256 public round = 0;
uint256 public nextPot = 0;
uint256 public profitTHT = 0;
// setting percent twelve hour auction
uint256 constant private THT_TOKEN_OWNERS = 10;
uint256 constant private KEY_HOLDERS_DIVIDEND = 30;
uint256 constant private REFERRAL = 10;
uint256 constant private FINAL_POT = 30;
// uint256 constant private NEXT_POT = 15;
uint256 constant private MARKETING = 5;
uint256 constant private MAGINITUDE = 2 ** 64;
uint256 constant private HALF_TIME = 12 hours;
uint256 constant private KEY_PRICE_DEFAULT = 0.005 ether;
uint256 constant private VERIFY_REFERRAL_PRICE= 0.01 ether;
// uint256 public stakingRequirement = 2 ether;
address public twelveHourTokenAddress;
TwelveHourTokenInterface public TwelveHourToken;
mapping(uint256 => Game) public games;
// bonus info
mapping(address => Player) public players;
mapping(address => bool) public referrals;
address[10] public teamMarketing;
struct Game {
uint256 round;
uint256 finalPot;
uint256 profitPerShare;
address keyHolder;
uint256 keyLevel;
uint256 endTime;
bool ended;
}
// distribute gen portion to key holders
struct Player {
uint256 curentRound;
uint256 lastRound;
uint256 bonus;
uint256 keys; // total key in round
uint256 dividends;
uint256 referrals;
int256 payouts;
}
event Buy(uint256 round, address buyer, uint256 amount, uint256 keyLevel);
event EndRound(uint256 round, uint256 finalPot, address keyHolder, uint256 keyLevel, uint256 endTime);
event Withdraw(address player, uint256 amount);
event WithdrawReferral(address player, uint256 amount);
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
constructor() public
{
owner = msg.sender;
// setting default team marketing
for (uint256 idx = 0; idx < 10; idx++) {
teamMarketing[idx] = owner;
}
}
function () public payable
{
if (msg.sender != twelveHourTokenAddress) buy(0x0);
}
function setTwelveHourToken(address _addr) public onlyOwner
{
twelveHourTokenAddress = _addr;
TwelveHourToken = TwelveHourTokenInterface(twelveHourTokenAddress);
}
function setTeamMaketing(address _addr, uint256 _idx) public onlyOwner
{
teamMarketing[_idx] = _addr;
}
function verifyReferrals() public payable disableContract
{
require(msg.value >= VERIFY_REFERRAL_PRICE);
referrals[msg.sender] = true;
owner.transfer(msg.value);
}
// --------------------------------------------------------------------------
// SETUP GAME
// --------------------------------------------------------------------------
function startGame() public onlyOwner
{
require(init == false);
init = true;
games[round].ended = true;
startRound();
}
function startRound() private
{
require(games[round].ended == true);
round = round + 1;
uint256 endTime = now + HALF_TIME;
games[round] = Game(round, nextPot, 0, 0x0, 1, endTime, false);
nextPot = 0;
}
function endRound() private disableContract
{
require(games[round].ended == false && games[round].endTime <= now);
Game storage g = games[round];
address keyHolder = g.keyHolder;
g.ended = true;
players[keyHolder].bonus += g.finalPot;
startRound();
// uint256 round, uint256 finalPot, address keyHolder, uint256 keyLevel, uint256 endTime
emit EndRound(g.round, g.finalPot, g.keyHolder, g.keyLevel, g.endTime);
}
// ------------------------------------------------------------------------------
// BUY KEY
// ------------------------------------------------------------------------------
function buy(address _referral) public payable disableContract
{
require(init == true);
require(games[round].ended == false);
require(msg.sender != _referral);
if (games[round].endTime <= now) endRound();
Game storage g = games[round];
uint256 keyPrice = SafeMath.mul(g.keyLevel, KEY_PRICE_DEFAULT);
uint256 repay = SafeMath.sub(msg.value, keyPrice);
//
uint256 _referralBonus = SafeMath.div(SafeMath.mul(keyPrice, REFERRAL), 100);
uint256 _profitTHT = SafeMath.div(SafeMath.mul(keyPrice, THT_TOKEN_OWNERS), 100);
uint256 _dividends = SafeMath.div(SafeMath.mul(keyPrice, KEY_HOLDERS_DIVIDEND), 100);
uint256 _marketingFee = SafeMath.div(SafeMath.mul(keyPrice, MARKETING), 100);
uint256 _finalPot = SafeMath.div(SafeMath.mul(keyPrice, FINAL_POT), 100);
uint256 _nextPot = keyPrice - (_referralBonus + _profitTHT + _dividends + _marketingFee + _finalPot);
if (msg.value < keyPrice) revert();
if (repay > 0) msg.sender.transfer(repay); // repay to player
if (_referral != 0x0 && referrals[_referral] == true) players[_referral].referrals += _referralBonus;
else owner.transfer(_referralBonus);
uint256 _fee = _dividends * MAGINITUDE;
nextPot = SafeMath.add(nextPot, _nextPot);
profitTHT = SafeMath.add(profitTHT, _profitTHT);
if (g.keyLevel > 1) {
g.profitPerShare += (_dividends * MAGINITUDE / g.keyLevel);
_fee = _fee - (_fee - (1 * (_dividends * MAGINITUDE / g.keyLevel)));
}
int256 _updatedPayouts = (int256) (g.profitPerShare * 1 - _fee);
updatePlayer(msg.sender, _updatedPayouts);
// update game
updateGame(_finalPot);
sendToTeamMaketing(_marketingFee);
sendProfitTTH();
emit Buy(round, msg.sender, keyPrice, games[round].keyLevel);
}
function withdraw() public disableContract
{
if (games[round].ended == false && games[round].endTime <= now) endRound();
if (games[players[msg.sender].curentRound].ended == true) updatePlayerEndRound(msg.sender);
Player storage p = players[msg.sender];
uint256 _dividends = calculateDividends(msg.sender, p.curentRound);
uint256 balance = SafeMath.add(p.bonus, _dividends);
balance = SafeMath.add(balance, p.dividends);
require(balance > 0);
if (address(this).balance >= balance) {
p.bonus = 0;
p.dividends = 0;
if (p.curentRound == round) p.payouts += (int256) (_dividends * MAGINITUDE);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
}
function withdrawReferral() public disableContract
{
Player storage p = players[msg.sender];
uint256 balance = p.referrals;
require(balance > 0);
if (address(this).balance >= balance) {
p.referrals = 0;
msg.sender.transfer(balance);
emit WithdrawReferral(msg.sender, balance);
}
}
function myDividends(address _addr)
public
view
returns(uint256 _dividends // bonus + dividends) {
Player memory p = players[_addr];
Game memory g = games[p.curentRound];
_dividends = p.bonus + p.dividends;
_dividends+= calculateDividends(_addr, p.curentRound);
if (g.ended == false &&
g.endTime <= now &&
g.keyHolder == _addr) {
_dividends += games[p.curentRound].finalPot;
}
}
function getData(address _addr)
public
view
returns(uint256 _round,
uint256 _finalPot,
uint256 _endTime,
uint256 _keyLevel,
uint256 _keyPrice,
address _keyHolder,
bool _ended,
// player info
uint256 _playerDividends,
uint256 _playerReferrals) {
_round = round;
Game memory g = games[_round];
_finalPot = g.finalPot;
_endTime = g.endTime;
_keyLevel = g.keyLevel;
_keyPrice = _keyLevel * KEY_PRICE_DEFAULT;
_keyHolder= g.keyHolder;
_ended = g.ended;
// player
_playerReferrals = players[_addr].referrals;
_playerDividends = myDividends(_addr);
}
function calculateDividends(address _addr, uint256 _round) public view returns(uint256 _devidends)
{
Game memory g = games[_round];
Player memory p = players[_addr];
if (p.curentRound == _round && p.lastRound < _round && _round != 0)
_devidends = (uint256) ((int256) (g.profitPerShare * p.keys) - p.payouts) / MAGINITUDE;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
// ---------------------------------------------------------------------------------------------
// INTERNAL FUNCTION
// ---------------------------------------------------------------------------------------------
function updatePlayer(address _addr, int256 _updatedPayouts) private
{
Player storage p = players[_addr];
if (games[p.curentRound].ended == true) updatePlayerEndRound(_addr);
if (p.curentRound != round) p.curentRound = round;
p.keys += 1;
p.payouts += (int256)(_updatedPayouts);
}
function updatePlayerEndRound(address _addr) private
{
Player storage p = players[_addr];
uint256 dividends = calculateDividends(_addr, p.curentRound);
p.dividends = SafeMath.add(p.dividends, dividends);
p.lastRound = p.curentRound;
p.keys = 0;
p.payouts = 0;
}
function updateGame(uint256 _finalPot) private
{
Game storage g = games[round];
// Final pot: 30%
g.finalPot = SafeMath.add(g.finalPot, _finalPot);
// update key holder
g.keyHolder = msg.sender;
// reset end time game
uint256 endTime = now + HALF_TIME;
endTime = endTime - 10 * g.keyLevel;
if (endTime <= now) endTime = now;
g.endTime = endTime;
// update key level
g.keyLevel += 1;
}
function sendToTeamMaketing(uint256 _marketingFee) private
{
// price * maketing / 100 * 10 /100 = price * maketing * 10 / 10000
uint256 profit = SafeMath.div(SafeMath.mul(_marketingFee, 10), 100);
for (uint256 idx = 0; idx < 10; idx++) {
teamMarketing[idx].transfer(profit);
}
}
function sendProfitTTH() private
{
uint256 balanceContract = totalEthereumBalance();
buyTHT(calEthSendToTHT(profitTHT));
exitTHT();
uint256 currentBalanceContract = totalEthereumBalance();
uint256 ethSendToTHT = SafeMath.sub(balanceContract, currentBalanceContract);
if (ethSendToTHT > profitTHT) {
// reset profit THT
profitTHT = 0;
nextPot = SafeMath.sub(nextPot, SafeMath.sub(ethSendToTHT, profitTHT));
} else {
profitTHT = SafeMath.sub(profitTHT, ethSendToTHT);
}
}
function calEthSendToTHT(uint256 _eth) private pure returns(uint256 _value)
{
_value = SafeMath.div(SafeMath.mul(_eth, 100), 64);
}
// conect to tht contract
function buyTHT(uint256 _value) private
{
TwelveHourToken.fallback.value(_value)();
}
function exitTHT() private
{
TwelveHourToken.exit();
}
}
| 214,002 | 11,822 |
32a2a22dc031a273ca80c8495e740a99f99e6b9269257ff034c204f61c0c1fb3
| 13,032 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/da/DA4472B161e854489e3724fFa44918a04b4Af9Cc_ve_dist.sol
| 3,490 | 12,406 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.11;
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 max(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
}
interface VotingEscrow {
struct Point {
int128 bias;
int128 slope; // # -dweight / dt
uint256 ts;
uint256 blk; // block
}
function user_point_epoch(uint tokenId) external view returns (uint);
function epoch() external view returns (uint);
function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
function point_history(uint loc) external view returns (Point memory);
function checkpoint() external;
function deposit_for(uint tokenId, uint value) external;
function token() external view returns (address);
}
contract ve_dist {
event CheckpointToken(uint time,
uint tokens);
event Claimed(uint tokenId,
uint amount,
uint claim_epoch,
uint max_epoch);
uint constant WEEK = 7 * 86400;
uint public start_time;
uint public time_cursor;
mapping(uint => uint) public time_cursor_of;
mapping(uint => uint) public user_epoch_of;
uint public last_token_time;
uint[1000000000000000] public tokens_per_week;
address public voting_escrow;
address public token;
uint public token_last_balance;
uint[1000000000000000] public ve_supply;
address public depositor;
constructor(address _voting_escrow) {
uint _t = block.timestamp / WEEK * WEEK;
start_time = _t;
last_token_time = _t;
time_cursor = _t;
address _token = VotingEscrow(_voting_escrow).token();
token = _token;
voting_escrow = _voting_escrow;
depositor = msg.sender;
erc20(_token).approve(_voting_escrow, type(uint).max);
}
function timestamp() external view returns (uint) {
return block.timestamp / WEEK * WEEK;
}
function _checkpoint_token() internal {
uint token_balance = erc20(token).balanceOf(address(this));
uint to_distribute = token_balance - token_last_balance;
token_last_balance = token_balance;
uint t = last_token_time;
uint since_last = block.timestamp - t;
last_token_time = block.timestamp;
uint this_week = t / WEEK * WEEK;
uint next_week = 0;
for (uint i = 0; i < 20; i++) {
next_week = this_week + WEEK;
if (block.timestamp < next_week) {
if (since_last == 0 && block.timestamp == t) {
tokens_per_week[this_week] += to_distribute;
} else {
tokens_per_week[this_week] += to_distribute * (block.timestamp - t) / since_last;
}
break;
} else {
if (since_last == 0 && next_week == t) {
tokens_per_week[this_week] += to_distribute;
} else {
tokens_per_week[this_week] += to_distribute * (next_week - t) / since_last;
}
}
t = next_week;
this_week = next_week;
}
emit CheckpointToken(block.timestamp, to_distribute);
}
function checkpoint_token() external {
assert(msg.sender == depositor);
_checkpoint_token();
}
function _find_timestamp_epoch(address ve, uint _timestamp) internal view returns (uint) {
uint _min = 0;
uint _max = VotingEscrow(ve).epoch();
for (uint i = 0; i < 128; i++) {
if (_min >= _max) break;
uint _mid = (_min + _max + 2) / 2;
VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(_mid);
if (pt.ts <= _timestamp) {
_min = _mid;
} else {
_max = _mid - 1;
}
}
return _min;
}
function _find_timestamp_user_epoch(address ve, uint tokenId, uint _timestamp, uint max_user_epoch) internal view returns (uint) {
uint _min = 0;
uint _max = max_user_epoch;
for (uint i = 0; i < 128; i++) {
if (_min >= _max) break;
uint _mid = (_min + _max + 2) / 2;
VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(tokenId, _mid);
if (pt.ts <= _timestamp) {
_min = _mid;
} else {
_max = _mid -1;
}
}
return _min;
}
function ve_for_at(uint _tokenId, uint _timestamp) external view returns (uint) {
address ve = voting_escrow;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint epoch = _find_timestamp_user_epoch(ve, _tokenId, _timestamp, max_user_epoch);
VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(_tokenId, epoch);
return Math.max(uint(int256(pt.bias - pt.slope * (int128(int256(_timestamp - pt.ts))))), 0);
}
function _checkpoint_total_supply() internal {
address ve = voting_escrow;
uint t = time_cursor;
uint rounded_timestamp = block.timestamp / WEEK * WEEK;
VotingEscrow(ve).checkpoint();
for (uint i = 0; i < 20; i++) {
if (t > rounded_timestamp) {
break;
} else {
uint epoch = _find_timestamp_epoch(ve, t);
VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(epoch);
int128 dt = 0;
if (t > pt.ts) {
dt = int128(int256(t - pt.ts));
}
ve_supply[t] = Math.max(uint(int256(pt.bias - pt.slope * dt)), 0);
}
t += WEEK;
}
time_cursor = t;
}
function checkpoint_total_supply() external {
_checkpoint_total_supply();
}
function _claim(uint _tokenId, address ve, uint _last_token_time) internal returns (uint) {
uint user_epoch = 0;
uint to_distribute = 0;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint _start_time = start_time;
if (max_user_epoch == 0) return 0;
uint week_cursor = time_cursor_of[_tokenId];
if (week_cursor == 0) {
user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch);
} else {
user_epoch = user_epoch_of[_tokenId];
}
if (user_epoch == 0) user_epoch = 1;
VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK;
if (week_cursor >= last_token_time) return 0;
if (week_cursor < _start_time) week_cursor = _start_time;
VotingEscrow.Point memory old_user_point;
for (uint i = 0; i < 50; i++) {
if (week_cursor >= _last_token_time) break;
if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) {
user_epoch += 1;
old_user_point = user_point;
if (user_epoch > max_user_epoch) {
user_point = VotingEscrow.Point(0,0,0,0);
} else {
user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
}
} else {
int128 dt = int128(int256(week_cursor - old_user_point.ts));
uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0);
if (balance_of == 0 && user_epoch > max_user_epoch) break;
if (balance_of > 0) {
to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor];
}
week_cursor += WEEK;
}
}
user_epoch = Math.min(max_user_epoch, user_epoch - 1);
user_epoch_of[_tokenId] = user_epoch;
time_cursor_of[_tokenId] = week_cursor;
emit Claimed(_tokenId, to_distribute, user_epoch, max_user_epoch);
return to_distribute;
}
function _claimable(uint _tokenId, address ve, uint _last_token_time) internal view returns (uint) {
uint user_epoch = 0;
uint to_distribute = 0;
uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId);
uint _start_time = start_time;
if (max_user_epoch == 0) return 0;
uint week_cursor = time_cursor_of[_tokenId];
if (week_cursor == 0) {
user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch);
} else {
user_epoch = user_epoch_of[_tokenId];
}
if (user_epoch == 0) user_epoch = 1;
VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK;
if (week_cursor >= last_token_time) return 0;
if (week_cursor < _start_time) week_cursor = _start_time;
VotingEscrow.Point memory old_user_point;
for (uint i = 0; i < 50; i++) {
if (week_cursor >= _last_token_time) break;
if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) {
user_epoch += 1;
old_user_point = user_point;
if (user_epoch > max_user_epoch) {
user_point = VotingEscrow.Point(0,0,0,0);
} else {
user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch);
}
} else {
int128 dt = int128(int256(week_cursor - old_user_point.ts));
uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0);
if (balance_of == 0 && user_epoch > max_user_epoch) break;
if (balance_of > 0) {
to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor];
}
week_cursor += WEEK;
}
}
return to_distribute;
}
function claimable(uint _tokenId) external view returns (uint) {
uint _last_token_time = last_token_time / WEEK * WEEK;
return _claimable(_tokenId, voting_escrow, _last_token_time);
}
function claim(uint _tokenId) external returns (uint) {
if (block.timestamp >= time_cursor) _checkpoint_total_supply();
uint _last_token_time = last_token_time;
_last_token_time = _last_token_time / WEEK * WEEK;
uint amount = _claim(_tokenId, voting_escrow, _last_token_time);
if (amount != 0) {
VotingEscrow(voting_escrow).deposit_for(_tokenId, amount);
token_last_balance -= amount;
}
return amount;
}
function claim_many(uint[] memory _tokenIds) external returns (bool) {
if (block.timestamp >= time_cursor) _checkpoint_total_supply();
uint _last_token_time = last_token_time;
_last_token_time = _last_token_time / WEEK * WEEK;
address _voting_escrow = voting_escrow;
uint total = 0;
for (uint i = 0; i < _tokenIds.length; i++) {
uint _tokenId = _tokenIds[i];
if (_tokenId == 0) break;
uint amount = _claim(_tokenId, _voting_escrow, _last_token_time);
if (amount != 0) {
VotingEscrow(_voting_escrow).deposit_for(_tokenId, amount);
total += amount;
}
}
if (total != 0) {
token_last_balance -= total;
}
return true;
}
// Once off event on contract initialize
function setDepositor(address _depositor) external {
require(msg.sender == depositor);
depositor = _depositor;
}
}
| 322,480 | 11,823 |
a363384f2245ef3d05291c3cd28a05592952cb432922cbb40ee75fd5fd080f50
| 19,376 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/71/71b4b21cbbf2e727bd8c0fe639d029c6eb9edc3f_GreenRewards.sol
| 4,776 | 18,165 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
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);
}
abstract contract Ownable {
address internal owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function Ownershiplock(uint256 time) public virtual onlyOwner {
_previousOwner = owner;
owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(owner, address(0));
}
function Ownershipunlock() 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;
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract GreenRewards is IBEP20, Ownable {
// Events
event AutoLiquify(uint256 amountAVAX, uint256 amountTokens);
event SetFees(uint256 liquidityFee, uint256 marketingFee, uint256 reflectionFee, uint256 teamFee, uint256 totalFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetFeeReceivers(address marketingReceiver, address teamFeeReceiver);
event StuckBalanceSent(uint256 amountAVAX, address recipient);
event SetMaxTx(uint256 maxTX);
event SetMaxWallet(uint256 maxWallet);
event MarketingFunds(uint256 amountAVAX, address recipient);
event TeamFunds(uint256 amountAVAX, address recipient);
event CanTransferBeforeLaunch(address holder, bool exempt);
event ForeignTokenTransfer(address tokenAddress, uint256 quantity);
// Mappings
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private isFeeExempt;
mapping (address => bool) private isTxLimitExempt;
mapping (address => bool) private canAddLiquidityBeforeLaunch;
// Supply
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
// Max Wallet & TX Limits
uint256 public _maxWalletSize = _tTotal / 10000 * 2;
uint256 public _maxTX = _tTotal / 10000 * 1;
// Basic Contract Info
string constant _name = 'GreenRewards';
string constant _symbol = 'GRWD';
uint8 constant _decimals = 9;
// Detailed Fees
uint256 private _reflectionFee = 2;
uint256 private _marketingFee = 8;
uint256 private _liquidityFee = 0;
uint256 private _teamFee = 0;
uint256 private totalFees = _marketingFee + _reflectionFee + _liquidityFee + _teamFee;
uint256 private contractFees = _marketingFee + _liquidityFee + _teamFee;
uint256 private _previousReflectionFee = _reflectionFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _previousliquidityFee = _liquidityFee;
uint256 private _previousteamFee = _teamFee;
// Fee Receiver
address private marketingFeeReceiver = 0xbdc13FDC2a4e94E7626d1dFf75DCF53F4dc5F060;
address private teamFeeReceiver = 0xbdc13FDC2a4e94E7626d1dFf75DCF53F4dc5F060;
IDEXRouter public router;
address public pair;
uint256 public launchedAt;
bool public swapEnabled = true;
uint256 public swapThreshold = _tTotal / 1000 * 1; // 0.1%
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor () Ownable(msg.sender) {
router = IDEXRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
pair = IDEXFactory(router.factory()).createPair(address(this), router.WAVAX());
_allowances[address(this)][address(router)] = type(uint256).max;
isFeeExempt[owner] = true;
isTxLimitExempt[owner] = true;
canAddLiquidityBeforeLaunch[owner] = true;
_balances[msg.sender] = _rTotal;
emit Transfer(address(0), msg.sender, _tTotal);
}
receive() external payable {}
// Basic Functions
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function getOwner() external view override returns (address) { return owner; }
function totalSupply() external view override returns (uint256) { return _tTotal; }
function balanceOf(address account) public view override returns (uint256) { return tokenFromReflection(_balances[account]);}
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]- (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 tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount / (currentRate);
}
// Internal Functions
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(!launched() && recipient == pair){
require(canAddLiquidityBeforeLaunch[sender]);
launch();
}
checkTxLimit(sender, amount);
if (recipient != pair &&
recipient != owner) {
require(isTxLimitExempt[recipient] || tokenFromReflection(_balances[recipient]) + amount <= _maxWalletSize, "Transfer amount exceeds the bag size.");
}
if(shouldSwapBack()){ swapBack(); }
_tokenTransfer(sender,recipient,amount);
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
if(!shouldTakeFee(sender) || !shouldTakeFee(recipient)) removeAllFee();
_transferStandard(sender, recipient, amount);
if(!shouldTakeFee(sender) || !shouldTakeFee(recipient)) restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rReflection, uint256 tTransferAmount, uint256 tFees) = _getValues(tAmount);
_balances[sender] = _balances[sender] - (rAmount);
_balances[recipient] = _balances[recipient] + (rTransferAmount);
_takeFees(tFees, rReflection);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeFees(uint256 tFees, uint256 rReflection) private {
_rTotal = _rTotal - (rReflection);
uint256 currentRate = _getRate();
uint256 rFees = tFees * (currentRate);
_balances[address(this)] = _balances[address(this)] + (rFees);
}
function checkTxLimit(address sender, uint256 amount) internal view {
require(amount <= _maxTX || isTxLimitExempt[sender], "TX Limit Exceeded");
}
function removeAllFee() private {
if(_reflectionFee == 0 && _marketingFee == 0 && _liquidityFee == 0) return;
_previousReflectionFee = _reflectionFee;
_previousMarketingFee = _marketingFee;
_previousliquidityFee = _liquidityFee;
_previousteamFee = _teamFee;
_reflectionFee = 0;
_marketingFee = 0;
_liquidityFee = 0;
_teamFee = 0;
contractFees = _marketingFee + _liquidityFee + _teamFee;
}
function restoreAllFee() private {
_reflectionFee = _previousReflectionFee;
_teamFee = _previousteamFee;
_marketingFee = _previousMarketingFee;
_liquidityFee = _previousliquidityFee;
contractFees = _marketingFee + _liquidityFee + _teamFee;
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function swapBack() internal swapping {
uint256 contractTokenBalance = balanceOf(address(this));
uint256 amountToLiquify = contractTokenBalance * _liquidityFee / contractFees / (2);
uint256 amountToSwap = contractTokenBalance - amountToLiquify;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = contractFees - (_liquidityFee / (2));
uint256 amountAVAXLiquidity = amountAVAX * _liquidityFee / totalAVAXFee / (2);
uint256 amountAVAXMarketing = amountAVAX * _marketingFee / totalAVAXFee;
uint256 amountAVAXTeam = amountAVAX - amountAVAXMarketing - amountAVAXLiquidity;
if(amountAVAXMarketing > 0) {payable(marketingFeeReceiver).transfer(amountAVAXMarketing);
emit MarketingFunds(amountAVAXMarketing, marketingFeeReceiver);
}
if(amountAVAXTeam > 0) {payable(teamFeeReceiver).transfer(amountAVAXTeam);
emit TeamFunds(amountAVAXTeam, teamFeeReceiver);
}
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
marketingFeeReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
function launched() internal view returns (bool) {
return launchedAt != 0;
}
function launch() internal {
launchedAt = block.timestamp;
}
// Reflections code
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tReflection, uint256 tFees) = _calculateTokenValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rReflection) = _calculateRateValues(tAmount, tReflection, tFees, currentRate);
return (rAmount, rTransferAmount, rReflection, tTransferAmount, tFees);
}
function _calculateTokenValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 feeAmount = tAmount * (totalFees) / 100;
uint256 tReflection = feeAmount * (_reflectionFee) / totalFees;
uint256 tFees = feeAmount * (contractFees) / totalFees;
uint256 tTransferAmount = tAmount - tReflection - tFees;
return (tTransferAmount, tReflection, tFees);
}
function _calculateRateValues(uint256 tAmount, uint256 tReflection, uint256 tFees, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount * (currentRate);
uint256 rReflection = tReflection * (currentRate);
uint256 rFees = tFees * (currentRate);
uint256 rTransferAmount = rAmount - (rReflection) - (rFees);
return (rAmount, rTransferAmount, rReflection);
}
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;
if (rSupply < _rTotal / (_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
// External Functions
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setFees(uint256 liquidityFee, uint256 marketingFee, uint256 reflectionFee, uint256 teamFee) external onlyOwner {
require(liquidityFee + marketingFee + reflectionFee + teamFee < 33, "Total fees must be below 33%");
_liquidityFee = liquidityFee;
_marketingFee = marketingFee;
_reflectionFee = reflectionFee;
_teamFee = teamFee;
totalFees = _liquidityFee + _marketingFee + _reflectionFee + _teamFee;
contractFees = _liquidityFee + _marketingFee + _teamFee;
emit SetFees(_liquidityFee, _marketingFee, _reflectionFee, _teamFee, totalFees);
}
function setFeeReceiver(address _marketingFeeReceiver, address _teamFeeReceiver) external onlyOwner {
marketingFeeReceiver = _marketingFeeReceiver;
teamFeeReceiver = _teamFeeReceiver;
emit SetFeeReceivers(marketingFeeReceiver, teamFeeReceiver);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount > 0, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function setMaxTx(uint256 maxTX) external onlyOwner {
require(maxTX > _tTotal / 1000, "Can't set maxTX below 0.1%");
_maxTX = maxTX;
emit SetMaxTx(maxTX);
}
function setMaxWallet(uint256 maxWallet) external onlyOwner {
require(maxWallet > _tTotal / 1000, "Can't set maxTX below 0.1%");
_maxWalletSize = maxWallet;
emit SetMaxWallet(maxWallet);
}
function setCanTransferBeforeLaunch(address holder, bool exempt) external onlyOwner {
canAddLiquidityBeforeLaunch[holder] = exempt; //Presale Address will be added as Exempt
isFeeExempt[holder] = exempt;
isTxLimitExempt[holder] = exempt;
emit CanTransferBeforeLaunch(holder, exempt);
}
// Stuck Balance Functions
function ClearStuckBalance() external onlyOwner {
uint256 contractBalance = address(this).balance;
payable(marketingFeeReceiver).transfer(contractBalance);
emit StuckBalanceSent(contractBalance, marketingFeeReceiver);
}
function transferForeignToken(address _token) public onlyOwner {
uint256 _contractBalance = IBEP20(_token).balanceOf(address(this));
payable(marketingFeeReceiver).transfer(_contractBalance);
emit ForeignTokenTransfer(_token, _contractBalance);
}
}
| 80,921 | 11,824 |
00996a577afbf7b30379944c34ed097cfd9b3cc39e23542391b0daa79a1e6b2a
| 17,565 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNiTHVApr4Y6gsGsy4yttWSPGbia4e1bqN_USCToken.sol
| 3,220 | 11,983 |
//SourceUnit: USCToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract USCToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'USCToken';
string private _symbol = 'USC';
uint8 private _decimals = 6;
uint256 private _totalSupply = 19131 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 3;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 4913 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 306,326 | 11,825 |
bdb2317616bc71e0c28f846d61c7346bb7df42cc7aedae1c72154b18d0b929b2
| 15,952 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe8940b7d6f17f24583894f807bc2764aa635d36b.sol
| 4,289 | 15,751 |
pragma solidity ^0.4.23;
library SafeMathLib {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract DateTimeLib {
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) internal pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) internal pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
dt.hour = getHour(timestamp);
dt.minute = getMinute(timestamp);
dt.second = getSecond(timestamp);
dt.weekday = getWeekday(timestamp);
}
function getYear(uint timestamp) internal pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) internal pure returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) internal pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) internal pure returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) internal pure returns (uint timestamp) {
uint16 i;
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
timestamp += DAY_IN_SECONDS * (day - 1);
timestamp += HOUR_IN_SECONDS * (hour);
timestamp += MINUTE_IN_SECONDS * (minute);
timestamp += second;
return timestamp;
}
}
interface IERC20 {
function totalSupply() external constant returns (uint256);
function balanceOf(address _owner) external constant returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address _spender, uint256 _value);
}
contract StandardToken is IERC20,DateTimeLib {
using SafeMathLib for uint256;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
string public constant symbol = "JCB";
string public constant name = "JoinCoin";
uint _totalSupply = 1000000000 * 10 ** 8;
uint8 public constant decimals = 8;
function totalSupply() external constant returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) external constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_value > 0 && balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value > 0 && allowed[_from][msg.sender] >= _value && balances[_from] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract LockableToken is StandardToken {
address internal developerReservedAddress = 0xf4ab0e0269E05163E65608F44E80A125A511a916;
uint[4] internal developerReservedUnlockTimes;
uint256[4] internal developerReservedBalanceLimits;
function getDeveloperReservedBalanceLimit() internal returns (uint256 balanceLimit) {
uint time = now;
for (uint index = 0; index < developerReservedUnlockTimes.length; index++) {
if (developerReservedUnlockTimes[index] == 0x0) {
continue;
}
if (time > developerReservedUnlockTimes[index]) {
developerReservedUnlockTimes[index] = 0x0;
} else {
return developerReservedBalanceLimits[index];
}
}
return 0;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
return transferInternal(msg.sender, _to, _value);
}
function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
return super.transferInternal(_from, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != 0x0 && _to != 0x0 && _value > 0x0);
if (_from == developerReservedAddress) {
uint256 balanceLimit = getDeveloperReservedBalanceLimit();
require(balances[_from].sub(balanceLimit) >= _value);
}
return super.transferFrom(_from, _to, _value);
}
event UnlockTimeChanged(uint index, uint unlockTime, uint newUnlockTime);
event LockInfo(address indexed publicOfferingAddress, uint index, uint unlockTime, uint256 balanceLimit);
}
contract TradeableToken is LockableToken {
address internal publicOfferingAddress = 0xbdB45923Bf511801F71EAeD4fbd926E48bA43DB5;
uint256 public exchangeRate = 4000;
function buy(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != 0x0);
require(publicOfferingAddress != 0x0);
require(exchangeRate > 0x0);
require(_weiAmount > 0x0);
uint256 exchangeToken = _weiAmount.mul(exchangeRate);
exchangeToken = exchangeToken.div(1 * 10 ** 10);
publicOfferingAddress.transfer(_weiAmount);
super.transferInternal(publicOfferingAddress, _beneficiary, exchangeToken);
}
event ExchangeRateChanged(uint256 oldExchangeRate,uint256 newExchangeRate);
}
contract OwnableToken is TradeableToken {
address internal owner = 0xfe71ea94aD48c03a8B1D5c8A371E36Fc0E05856A;
mapping(address => uint) administrators;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdministrator() {
require(msg.sender == owner || administrators[msg.sender] > 0x0);
_;
}
function transferOwnership(address _newOwner) onlyOwner public {
require(_newOwner != address(0));
owner = _newOwner;
emit OwnershipTransferred(owner, _newOwner);
}
function addAdministrator(address _adminAddress) onlyOwner public {
require(_adminAddress != address(0));
require(administrators[_adminAddress] <= 0x0);
administrators[_adminAddress] = 0x1;
emit AddAdministrator(_adminAddress);
}
function removeAdministrator(address _adminAddress) onlyOwner public {
require(_adminAddress != address(0));
require(administrators[_adminAddress] > 0x0);
administrators[_adminAddress] = 0x0;
emit RemoveAdministrator(_adminAddress);
}
function setExchangeRate(uint256 _exchangeRate) public onlyAdministrator returns (bool success) {
require(_exchangeRate > 0x0);
uint256 oldExchangeRate = exchangeRate;
exchangeRate = _exchangeRate;
emit ExchangeRateChanged(oldExchangeRate, exchangeRate);
return true;
}
function changeUnlockTime(uint _index, uint _unlockTime) public onlyAdministrator returns (bool success) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _unlockTime > 0x0);
if(_index > 0x0) {
uint beforeUnlockTime = developerReservedUnlockTimes[_index - 1];
require(beforeUnlockTime == 0x0 || beforeUnlockTime < _unlockTime);
}
if(_index < developerReservedUnlockTimes.length - 1) {
uint afterUnlockTime = developerReservedUnlockTimes[_index + 1];
require(afterUnlockTime == 0x0 || _unlockTime < afterUnlockTime);
}
uint oldUnlockTime = developerReservedUnlockTimes[_index];
developerReservedUnlockTimes[_index] = _unlockTime;
emit UnlockTimeChanged(_index,oldUnlockTime,_unlockTime);
return true;
}
function getDeveloperReservedLockInfo(uint _index) public onlyAdministrator returns (uint, uint256) {
require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _index < developerReservedBalanceLimits.length);
emit LockInfo(developerReservedAddress,_index,developerReservedUnlockTimes[_index],developerReservedBalanceLimits[_index]);
return (developerReservedUnlockTimes[_index], developerReservedBalanceLimits[_index]);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdministrator(address indexed adminAddress);
event RemoveAdministrator(address indexed adminAddress);
}
contract JCB is OwnableToken {
function JCB() public {
balances[owner] = 500000000 * 10 ** 8;
balances[publicOfferingAddress] = 300000000 * 10 ** 8;
uint256 developerReservedBalance = 200000000 * 10 ** 8;
balances[developerReservedAddress] = developerReservedBalance;
developerReservedUnlockTimes =
[
DateTimeLib.toTimestamp(2019, 7, 1),
DateTimeLib.toTimestamp(2020, 7, 1),
DateTimeLib.toTimestamp(2021, 7, 1),
DateTimeLib.toTimestamp(2022, 7, 1)
];
developerReservedBalanceLimits =
[
developerReservedBalance,
developerReservedBalance - (developerReservedBalance / 4) * 1,
developerReservedBalance - (developerReservedBalance / 4) * 2,
developerReservedBalance - (developerReservedBalance / 4) * 3
];
}
function() public payable {
buy(msg.sender, msg.value);
}
}
| 208,021 | 11,826 |
951e92a1950c4f5fc6617b87943fc39b34cdd88da21592153be9eaa8d799cd07
| 29,441 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/33/337e2c10235d4DC4dd6E38e1c6B25859DEf53F93_WATER.sol
| 5,179 | 18,685 |
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 WATER 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 = 70000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Fire Dao';
string private constant _symbol = 'WATER';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 70000 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 != 0x143b92CD8BDb4F7A196D9D39310EE951eDe40C17, '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;
}
}
| 311,474 | 11,827 |
4915be0c7562dd2098be52c2cd98f2831f6540c132bb916db93a48c94b686a92
| 16,181 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x65507341fb08124920f2c12e91fb0b922093932c.sol
| 3,885 | 15,192 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/KyberReserveInterface.sol
/// @title Kyber Reserve contract
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/Utils2.sol
contract Utils2 is Utils {
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
function getDecimalsSafe(ERC20 token) internal returns(uint) {
if (decimals[token] == 0) {
setDecimals(token);
}
return decimals[token];
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
internal pure returns(uint)
{
require(srcAmount <= MAX_QTY);
require(destAmount <= MAX_QTY);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
}
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/oasisContracts/KyberBancorReserve.sol
contract IBancorConverter {
function getReturn(ERC20 _fromToken, ERC20 _toToken, uint _amount) public view returns (uint256, uint256);
}
contract KyberBancorReserve is KyberReserveInterface, Withdrawable, Utils2 {
address public sanityRatesContract = 0;
address public kyberNetwork;
IBancorConverter public bancor;
ERC20 public token;
ERC20 public constant BANCOR_ETH = ERC20(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315);
bool public tradeEnabled = true;
int public buyPremiumInBps = -25;
int public sellPremiumInBps = -25;
uint public lastBuyRate;
uint public lastSellRate;
uint public baseEthQty = 5 ether;
function KyberBancorReserve(IBancorConverter _bancor,
address _kyberNetwork,
ERC20 _token,
address _admin)
public
{
require(_bancor != address(0));
require(_kyberNetwork != address(0));
require(_token != address(0));
kyberNetwork = _kyberNetwork;
bancor = _bancor;
token = _token;
admin = _admin;
setDecimals(token);
setDecimals(ETH_TOKEN_ADDRESS);
}
function() public payable {
// anyone can deposit ether
}
function setPremium(int newBuyPremium, int newSellPremium, uint newEthBaseQty) public onlyAdmin {
require(newBuyPremium >= -10000);
require(newBuyPremium <= int(MAX_QTY));
require(newSellPremium >= -10000);
require(newSellPremium <= int(MAX_QTY));
sellPremiumInBps = newSellPremium;
buyPremiumInBps = newBuyPremium;
baseEthQty = newEthBaseQty;
}
event TradeExecute(address indexed sender,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event KyberNetworkSet(address kyberNetwork);
function setKyberNetwork(address _kyberNetwork) public onlyAdmin {
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
KyberNetworkSet(kyberNetwork);
}
function valueAfterAddingPremium(uint val, int premiumInBps) public pure returns(uint) {
require(val <= MAX_QTY);
return val * uint(10000 + premiumInBps) / 10000;
}
function shouldUseInternalInventory(uint val,
ERC20 dest) public view returns(bool) {
if (dest == token) {
return val <= token.balanceOf(this);
}
else {
return val <= this.balance;
}
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
srcQty;
blockNumber;
if (!tradeEnabled) return 0;
if (!validTokens(src, dest)) return 0;
if (src == ETH_TOKEN_ADDRESS) return lastBuyRate;
else return lastSellRate;
}
function getBancorRatePlusPremiumForEthQty(uint ethQty) public view returns(uint, uint) {
uint tokenReturn;
uint ethReturn;
uint buyRate = 0;
uint sellRate = 0;
if (!tradeEnabled) return (0,0);
(tokenReturn,) = bancor.getReturn(BANCOR_ETH, token, ethQty);
(ethReturn,) = bancor.getReturn(token, BANCOR_ETH, tokenReturn);
tokenReturn = valueAfterAddingPremium(tokenReturn, buyPremiumInBps);
ethReturn = valueAfterAddingPremium(ethReturn, sellPremiumInBps);
if(! shouldUseInternalInventory(tokenReturn,token)) tokenReturn = 0;
if(! shouldUseInternalInventory(ethReturn,ETH_TOKEN_ADDRESS)) ethReturn = 0;
if(tokenReturn > 0) buyRate = calcRateFromQty(ethQty, tokenReturn, getDecimals(ETH_TOKEN_ADDRESS), getDecimals(token));
if(ethReturn > 0) sellRate = calcRateFromQty(tokenReturn, ethReturn, getDecimals(token), getDecimals(ETH_TOKEN_ADDRESS));
return (buyRate,sellRate);
}
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
require(validTokens(srcToken, destToken));
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
if (srcToken != ETH_TOKEN_ADDRESS) require(token.transferFrom(msg.sender,this,srcAmount));
uint userExpectedDestAmount = calcDstQty(srcAmount, getDecimals(srcToken), getDecimals(destToken), conversionRate);
if(destToken == ETH_TOKEN_ADDRESS) destAddress.transfer(userExpectedDestAmount);
else require(destToken.transfer(destAddress, userExpectedDestAmount));
TradeExecute(msg.sender, srcToken, srcAmount, destToken, userExpectedDestAmount, destAddress);
(lastBuyRate, lastSellRate) = getBancorRatePlusPremiumForEthQty(baseEthQty);
return true;
}
function validTokens(ERC20 src, ERC20 dest) internal view returns (bool valid) {
return ((token == src && ETH_TOKEN_ADDRESS == dest) ||
(token == dest && ETH_TOKEN_ADDRESS == src));
}
}
| 198,122 | 11,828 |
34c273c2810605e9a3d64e5068148da8485e14b8c85434e57cfbe9a239ebc9e5
| 22,189 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7d/7d2040e4eeed5c9046993e9ffd581404f943652f_VestingWallet.sol
| 2,563 | 10,594 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (finance/VestingWallet.sol)
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function owner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}
contract VestingWallet is Context {
event EtherReleased(uint256 amount);
event ERC20Released(address indexed token, uint256 amount);
uint256 private _released;
mapping(address => uint256) private _erc20Released;
address private _beneficiary;
uint64 private immutable _start;
uint64 private immutable _duration;
constructor(address beneficiaryAddress,
uint64 startTimestamp,
uint64 durationSeconds) {
require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address");
_beneficiary = beneficiaryAddress;
_start = startTimestamp;
_duration = durationSeconds;
}
receive() external payable virtual {}
function beneficiary() public view virtual returns (address) {
return _beneficiary;
}
function changeBeneficiary(address newBeneficiary) public virtual{
require(msg.sender == _beneficiary, "ECR20: Only current beneficiary can change beneficiaries");
_beneficiary = newBeneficiary;
}
function start() public view virtual returns (uint256) {
return _start;
}
function duration() public view virtual returns (uint256) {
return _duration;
}
function released() public view virtual returns (uint256) {
return _released;
}
function released(address token) public view virtual returns (uint256) {
return _erc20Released[token];
}
function release() public virtual {
uint256 releasable = vestedAmount(uint64(block.timestamp)) - released();
_released += releasable;
emit EtherReleased(releasable);
Address.sendValue(payable(beneficiary()), releasable);
}
function release(address token) public virtual {
uint256 releasable = vestedAmount(token, uint64(block.timestamp)) - released(token);
_erc20Released[token] += releasable;
emit ERC20Released(token, releasable);
SafeERC20.safeTransfer(IERC20(token), beneficiary(), releasable);
}
function vestedAmount(uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(address(this).balance + released(), timestamp);
}
function vestedAmount(address token, uint64 timestamp) public view virtual returns (uint256) {
return _vestingSchedule(IERC20(token).balanceOf(address(this)) + released(token), timestamp);
}
function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) {
if (timestamp < start()) {
return 0;
} else if (timestamp > start() + duration()) {
return totalAllocation;
} else {
return (totalAllocation * (timestamp - start())) / duration();
}
}
}
| 74,533 | 11,829 |
21b14ee4b41603c11923cca379806d285f0fd88ae9b9a67d1041e60f40055766
| 27,427 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e4/E4809Ed214631017737A3d7FA3e78600Ee96Eb85_AvaxProxy.sol
| 2,847 | 12,032 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
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 {}
}
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;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library 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 _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
_upgradeTo(newImplementation);
}
}
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 AvaxProxy is TransparentUpgradeableProxy {
constructor(address logic, address admin, bytes memory data) TransparentUpgradeableProxy(logic, admin, data) {}
}
| 94,861 | 11,830 |
1a9b3d4c0d08bd60fd96fd84ffd8b5069957eddb66714c5dedc92d8613c99226
| 12,566 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2eee31223b1d043e6b63da8360b682e3fd2ebfbe.sol
| 3,276 | 11,861 |
pragma solidity ^0.4.25;
contract EtherMiner{
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "EtherMiner";
string public symbol = "ETM";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 25;
uint8 constant internal refferalFee_ = 30;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.0000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function 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;
}
}
| 216,025 | 11,831 |
081782a7285b1c7e71f021896a6973687b8e50a02eea36f8165c8a09a50a2122
| 16,895 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00b05ff05065c1dd6fcced1c6b375a63497a7d58.sol
| 3,315 | 13,529 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
//pragma experimental ABIEncoderV2;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function safeDiv(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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
//-------------------------------------------------------------------------------------
abstract contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public virtual view returns (uint);
function allowance(address owner, address spender) public virtual view returns (uint);
function transfer(address to, uint value) public virtual returns (bool ok);
function transferFrom(address from, address to, uint value) public virtual returns (bool ok);
function approve(address spender, uint value) public virtual returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
abstract contract ERC223 is ERC20 {
function transfer(address to, uint value, bytes memory data) public virtual returns (bool ok);
function transferFrom(address from, address to, uint value, bytes memory data) public virtual returns (bool ok);
}
abstract contract ERC223Receiver {
function tokenFallback(address _sender, address _origin, uint _value, bytes memory _data) public virtual returns (bool ok);
}
abstract contract Standard223Receiver is ERC223Receiver {
function supportsToken(address token) public virtual view returns (bool);
}
//-------------------------------------------------------------------------------------
//Implementation
contract MetaMediaToken223Token_15 is ERC20, ERC223, Standard223Receiver, SafeMath {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg SBX
address contrInitiator;
address thisContract;
bool isTokenSupport;
mapping(address => bool) isSendingLocked;
bool isAllTransfersLocked;
uint oneTransferLimit;
uint oneDayTransferLimit;
struct TransferInfo {
//address sender; //maybe use in the future
//address from; //no need because all this is kept in transferInfo[_from]
//address to; //maybe use in the future
uint256 value;
uint time;
}
struct TransferInfos {
mapping (uint => TransferInfo) ti;
uint tc;
}
mapping (address => TransferInfos) transferInfo;
event SetIsSendingLocked(address _from, bool _lock);
event SetIsAllTransfersLocked(bool _lock);
//-------------------------------------------------------------------------------------
//from ExampleToken
constructor() {
decimals = 18; // Amount of decimals for display purposes
name = "Meta Media Token"; // Set the name for display purposes
symbol = 'MML'; // Set the symbol for display purposes
uint initialBalance = (10 ** uint256(decimals)) * 1000*1000*1000;
balances[msg.sender] = initialBalance;
totalSupply = initialBalance;
contrInitiator = msg.sender;
thisContract =address(this);
isTokenSupport = false;
isAllTransfersLocked = true;
oneTransferLimit = (10 ** uint256(decimals)) * 50*1000*1001; // to simulate no limit
oneDayTransferLimit = (10 ** uint256(decimals)) * 50*1000*1001; // to simulate no limit
// Ideally call token fallback here too
}
//-------------------------------------------------------------------------------------
//from StandardToken
function super_transfer(address _to, uint _value) internal returns (bool success) {
require(!isSendingLocked[msg.sender]);
require(_value <= oneTransferLimit);
require(balances[msg.sender] >= _value);
if(msg.sender == contrInitiator) {
//no restricton
} else {
require(!isAllTransfersLocked);
require(safeAdd(getLast24hSendingValue(msg.sender), _value) <= oneDayTransferLimit);
}
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
uint tc=transferInfo[msg.sender].tc;
transferInfo[msg.sender].ti[tc].value = _value;
transferInfo[msg.sender].ti[tc].time = block.timestamp;
transferInfo[msg.sender].tc = safeAdd(transferInfo[msg.sender].tc, 1);
emit Transfer(msg.sender, _to, _value);
return true;
}
function super_transferFrom(address _from, address _to, uint _value) internal returns (bool success) {
require(!isSendingLocked[_from]);
require(_value <= oneTransferLimit);
require(balances[_from] >= _value);
if(msg.sender == contrInitiator && _from == thisContract) {
// no restriction
} else {
require(!isAllTransfersLocked);
require(safeAdd(getLast24hSendingValue(_from), _value) <= oneDayTransferLimit);
uint loc_allowance = allowed[_from][msg.sender];
require(loc_allowance >= _value);
uint new_allowance = safeSub(loc_allowance, _value);
allowed[_from][msg.sender] = new_allowance;
emit Approval(_from, msg.sender, new_allowance);
}
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
uint tc=transferInfo[_from].tc;
transferInfo[_from].ti[tc].value = _value;
transferInfo[_from].ti[tc].time = block.timestamp;
transferInfo[_from].tc = safeAdd(transferInfo[_from].tc, 1);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public override view returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) public override returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public override view returns (uint remaining) {
return allowed[_owner][_spender];
}
//-------------------------------------------------------------------------------------
//from Standard223Token
//function that is called when a user or another contract wants to transfer funds
function transfer(address _to, uint _value, bytes memory _data) public override returns (bool success) {
//filtering if the target is a contract with bytecode inside it
if (!super_transfer(_to, _value)) assert(false); // do a normal token transfer
if (isContract(_to)) {
if(!contractFallback(msg.sender, _to, _value, _data)) assert(false);
}
return true;
}
function transferFrom(address _from, address _to, uint _value, bytes memory _data) public override returns (bool success) {
if (!super_transferFrom(_from, _to, _value)) assert(false); // do a normal token transfer
if (isContract(_to)) {
if(!contractFallback(_from, _to, _value, _data)) assert(false);
}
return true;
}
function transfer(address _to, uint _value) public override returns (bool success) {
return transfer(_to, _value, new bytes(0));
}
function transferFrom(address _from, address _to, uint _value) public override returns (bool success) {
return transferFrom(_from, _to, _value, new bytes(0));
}
//function that is called when transaction target is a contract
function contractFallback(address _origin, address _to, uint _value, bytes memory _data) private returns (bool success) {
ERC223Receiver reciever = ERC223Receiver(_to);
return reciever.tokenFallback(msg.sender, _origin, _value, _data);
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
//-------------------------------------------------------------------------------------
//from Standard223Receiver
Tkn tkn;
struct Tkn {
address addr;
address sender;
address origin;
uint256 value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _sender, address _origin, uint _value, bytes memory _data) public override returns (bool ok) {
if (!supportsToken(msg.sender)) return false;
// Problem: This will do a sstore which is expensive gas wise. Find a way to keep it in memory.
tkn = Tkn(msg.sender, _sender, _origin, _value, _data, getSig(_data));
__isTokenFallback = true;
// if (!address(this).delegatecall(_data)) return false;
(bool success, bytes memory response) = address(this).delegatecall(_data);
response = response; //!!!!! will it work?
if(!success) return false;
// avoid doing an overwrite to .token, which would be more expensive
// makes accessing .tkn values outside tokenPayable functions unsafe
__isTokenFallback = false;
return true;
}
function getSig(bytes memory _data) private pure returns (bytes4 sig) {
uint l = _data.length < 4 ? _data.length : 4;
for (uint i = 0; i < l; i++) {
sig = bytes4(uint32(uint32(sig) + uint8(_data[i]) * (2 ** (8 * (l - 1 - i)))));
}
}
bool __isTokenFallback;
modifier mod_tokenPayable() {
if (!__isTokenFallback) assert(false);
_; //_ is a special character used in modifiers
}
//function supportsToken(address token) public pure returns (bool); //moved up
//-------------------------------------------------------------------------------------
//from ExampleReceiver
function tokenPayable() external mod_tokenPayable() {
emit LogTokenPayable(0, tkn.addr, tkn.sender, tkn.value);
}
function supportsToken(address token) public override view returns (bool) {
//do not need to to anything with that token address?
//if (token == 0) { //attila addition
if (token != thisContract) { //attila addition, support only our own token, not others' token
return false;
}
if(!isTokenSupport) { //attila addition
return false;
}
return true;
}
event LogTokenPayable(uint i, address token, address sender, uint value);
//-------------------------------------------------------------------------------------
// My extensions
function setIsAllTransfersLocked(bool _lock) public {
require(msg.sender == contrInitiator);
isAllTransfersLocked = _lock;
emit SetIsAllTransfersLocked(_lock);
}
function setIsSendingLocked(address _from, bool _lock) public {
require(msg.sender == contrInitiator);
isSendingLocked[_from] = _lock;
emit SetIsSendingLocked(_from, _lock);
}
function getIsAllTransfersLocked() public view returns (bool ok) {
return isAllTransfersLocked;
}
function getIsSendingLocked(address _from) public view returns (bool ok) {
return isSendingLocked[_from];
}
function getLast24hSendingValue(address _from) public view returns (uint totVal) {
totVal = 0; //declared above;
uint tc = transferInfo[_from].tc;
for(uint i = tc ; i >= 1 ; i--) {
// if(block.timestamp - transferInfo[_from].ti[i-1].time < 10 minutes) {
// if(block.timestamp - transferInfo[_from].ti[i-1].time < 1 hours) {
if(block.timestamp - transferInfo[_from].ti[i-1].time < 1 days) {
totVal = safeAdd(totVal, transferInfo[_from].ti[i-1].value);
} else {
break;
}
require(tc - i < 99);
}
}
function airdropIndividual(address[] memory _recipients, uint256[] memory _values, uint256 _elemCount, uint _totalValue) public returns (bool success) {
require(_recipients.length == _elemCount);
require(_values.length == _elemCount);
require(_elemCount <= 50);
uint256 totalValue = 0;
for(uint i = 0; i< _recipients.length; i++) {
totalValue = safeAdd(totalValue, _values[i]);
}
require(totalValue == _totalValue);
for(uint i = 0; i< _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
return true;
}
}
| 343,950 | 11,832 |
5f0773259f0c344906f73f458cc667e32350f794110dc056478d9efdf2c96bde
| 34,492 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c7/C79A68DDbf6DDD146b467A680644Db8dFE56D774_PopMart.sol
| 4,264 | 17,599 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
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 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;
}
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract PopMart is ERC20, Ownable {
using SafeMath for uint256;
uint256 OPENING_INTERVAL = 3 minutes;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
uint256 public transferStartTime;
mapping(address => bool) private _isExcludedFromFees;
constructor(string memory name_,
string memory symbol_,
uint256 totalSupply_,
IUniswapV2Router02 uniswapV2Router_,
uint256 transferStartTime_) payable ERC20(name_, symbol_) {
uniswapV2Router = uniswapV2Router_;
transferStartTime = transferStartTime_;
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(uniswapV2Router.WETH(),
address(this));
excludeFromFees(owner(), true);
_mint(msg.sender, totalSupply_ * 10 ** decimals());
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
function _transfer(address from,
address to,
uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
require(_isTransferStart(from, to), "PopMart: transfer not started");
super._transfer(from, to, amount);
}
function _isTransferStart(address _from,
address _to) private view returns (bool) {
return
transferStartTime.add(_to == uniswapV2Pair ? OPENING_INTERVAL : 0) <=
block.timestamp ||
_isExcludedFromFees[_from] ||
_isExcludedFromFees[_to];
}
function setTransferStartTime(uint256 _transferStartTime) external onlyOwner {
transferStartTime = _transferStartTime;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
if (_isExcludedFromFees[account] != excluded) {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
}
function excludeMultipleAccountsFromFees(address[] calldata accounts,
bool excluded) external onlyOwner {
for (uint256 i = 0; i < accounts.length; i++) {
_isExcludedFromFees[accounts[i]] = excluded;
}
emit ExcludeMultipleAccountsFromFees(accounts, excluded);
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
}
| 47,574 | 11,833 |
eca5122266bb847fc82d768ad44357f419e8af9753a81523c66dc6159fcef6a4
| 21,958 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x94d940ceb4eb87a18c903804bb2c44910edb6453_nonpublicVarAccessdByPublicFunc.sol
| 3,604 | 14,195 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract LexDAORole is Context {
using Roles for Roles.Role;
event LexDAOAdded(address indexed account);
event LexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
constructor () internal {
_addLexDAO(_msgSender());
}
modifier onlyLexDAO() {
require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role");
_;
}
function isLexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function addLexDAO(address account) public onlyLexDAO {
_addLexDAO(account);
}
function renounceLexDAO() public {
_removeLexDAO(_msgSender());
}
function _addLexDAO(address account) internal {
_lexDAOs.add(account);
emit LexDAOAdded(account);
}
function _removeLexDAO(address account) internal {
_lexDAOs.remove(account);
emit LexDAORemoved(account);
}
}
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);
}
contract ICHAI {
function balanceOf(address usr) external returns (uint);
function transfer(address dst, uint wad) external returns (bool);
function dai(address usr) external returns (uint wad);
function dai(uint chai) external returns (uint wad);
function join(address dst, uint wad) external;
}
interface ICERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(uint256) external returns (uint256);
function exchangeRateCurrent() external returns (uint256);
function supplyRatePerBlock() external returns (uint256);
}
contract LexGrow is LexDAORole { // Deal depositing for Digital Dollars that earn on DSR & Compound
using SafeMath for uint256;
// $DAI details:
address private daiToken = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
IERC20 internal dai = IERC20(daiToken);
// $CHAI details:
address private chaiToken = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
ICHAI internal chai = ICHAI(chaiToken);
// <$> LXG <$> details:
address private vault = address(this);
address payable internal manager;
uint8 public version = 2;
uint256 internal depositFee;
uint256 internal lxg; // index for registered LexGrow
string public emoji = "11111";
mapping (uint256 => Deposit) internal deposit;
struct Deposit {
address client;
address provider;
address compoundToken;
uint256 amount;
uint256 wrap;
uint256 termination;
uint256 index;
string details;
bool dsr;
bool disputed;
bool released;
}
// LXG Contract Events:
event Log(string, uint256); // log for Compound interactions
event Registered(address indexed client, address indexed provider, uint256 indexed index);
event Released(uint256 indexed index);
event Disputed(uint256 indexed index, string indexed details);
event Resolved(address indexed resolver, uint256 indexed index, string indexed details);
event ManagerTransferred(address indexed manager, string indexed details);
constructor () public {
dai.approve(chaiToken, uint(-1));
manager = msg.sender;
depositFee = 0;
}
function dealDepositDSR(// register $DAI deal deposit with DSR via $CHAI; arbitration via lexDAO
address provider,
uint256 amount,
uint256 termination,
string memory details) public payable {
require(msg.value == depositFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 index = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
lxg = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
dai.transferFrom(msg.sender, vault, amount); // deposit $DAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 balance = chai.balanceOf(vault); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
chai.join(vault, amount); // wrap into $CHAI and store in vault //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
deposit[index] = Deposit(// log deal deposit details //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
msg.sender,
provider,
chaiToken, //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
amount,
chai.balanceOf(vault).sub(balance), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
termination,
index,
details,
true,
false,
false);
address(manager).transfer(msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Registered(msg.sender, provider, index);
}
function dealDepositCompound(// register $cToken deal deposit with interest via Compound; arbitration via lexDAO
address provider,
address underlyingToken,
address compoundToken,
uint256 amount,
uint256 termination,
string memory details) public payable returns (uint) {
require(msg.value == depositFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
IERC20 uToken = IERC20(underlyingToken);
ICERC20 cToken = ICERC20(compoundToken);
// Amount of current exchange rate from $cToken to underlying
uint256 exchangeRateMantissa = cToken.exchangeRateCurrent();
emit Log("Exchange Rate (scaled up by 1e18)", exchangeRateMantissa);
// Amount added to supply balance this block
uint256 supplyRateMantissa = cToken.supplyRatePerBlock();
emit Log("Supply Rate: (scaled up by 1e18)", supplyRateMantissa);
// Approve transfer on underlying ERC20 token contract
uToken.approve(compoundToken, amount);
// Mint cTokens
uToken.transferFrom(msg.sender, vault, amount); // deposit $uToken //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 balance = cToken.balanceOf(vault); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint mintResult = cToken.mint(amount); // wrap into $cToken and store in vault
uint256 index = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
lxg = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
deposit[index] = Deposit(// log deal deposit details //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
msg.sender,
provider,
compoundToken,
amount,
cToken.balanceOf(vault).sub(balance), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
termination,
index,
details,
false,
false,
false);
address(manager).transfer(msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Registered(msg.sender, provider, index);
return mintResult;
}
function release(uint256 index) public {
Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(depos.disputed == false); // program safety check / status
require(depos.released == false); // program safety check / status
require(now <= depos.termination); // program safety check / time
require(msg.sender == depos.client); // program safety check / authorization
if (depos.dsr == true) {
chai.transfer(depos.provider, depos.wrap); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.provider, depos.wrap);
}
depos.released = true;
emit Released(index);
}
function withdraw(uint256 index) public { // withdraw deposit wrap if termination time passes
Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(depos.disputed == false); // program safety check / status
require(depos.released == false); // program safety check / status
require(now >= depos.termination); // program safety check / time
if (depos.dsr == true) {
chai.transfer(depos.client, depos.wrap); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.client, depos.wrap);
}
depos.released = true;
emit Released(index);
}
function dispute(uint256 index, string memory details) public {
Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(depos.released == false); // program safety check / status
require(now <= depos.termination); // program safety check / time
require(msg.sender == depos.client || msg.sender == depos.provider); // program safety check / authorization
depos.disputed = true;
emit Disputed(index, details);
}
function resolve(uint256 index, uint256 clientAward, uint256 providerAward, string memory details) public onlyLexDAO {
Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(depos.disputed == true); // program safety check / status
require(depos.released == false); // program safety check / status
require(clientAward.add(providerAward) == depos.wrap); // program safety check / economics
require(msg.sender != depos.client); // program safety check / authorization
require(msg.sender != depos.provider); // program safety check / authorization
if (depos.dsr == true) {
chai.transfer(depos.client, clientAward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
chai.transfer(depos.provider, providerAward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
} else {
ICERC20 cToken = ICERC20(depos.compoundToken);
cToken.transfer(depos.client, clientAward);
cToken.transfer(depos.provider, providerAward);
}
depos.released = true;
emit Resolved(msg.sender, index, details);
}
function newDepositFee(uint256 weiAmount) public {
require(msg.sender == manager); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
depositFee = weiAmount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transferManager(address payable newManager, string memory details) public {
require(msg.sender == manager); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
manager = newManager; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit ManagerTransferred(manager, details); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
| 279,775 | 11,834 |
624d02de50b313d6c7769b43e190098c56ba3a7a69398d31d6343e0fe76fdf92
| 18,121 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xefc1752f4b196d6da51feb3fa5383b0fed2e4f8a.sol
| 5,112 | 17,924 |
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address owner;
address Main_address;
address public main_address;
address Upline_address;
address public upline_address;
mapping (address => bool) managers;
constructor() public {
owner = msg.sender;
main_address = msg.sender;
upline_address = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only for owner");
_;
}
function transferOwnership(address _owner) public onlyOwner {
owner = _owner;
}
}
contract ETHStvo is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) SPONSOR;
mapping (uint => uint) INTRODUCER;
mapping (uint => uint) UPLINE;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 3;
struct UserStruct {
bool isExist;
uint level;
uint introducedTotal;
uint referrerID;
uint introducerID;
address wallet;
uint[] introducers;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint stats = 0 ether;
uint Stats = 0 ether;
bool public paused = false;
constructor() public {
LEVEL_PRICE[0.1 ether] = 1;
LEVEL_PRICE[0.15 ether] = 2;
LEVEL_PRICE[0.5 ether] = 3;
LEVEL_PRICE[1.5 ether] = 4;
LEVEL_PRICE[3.5 ether] = 5;
LEVEL_PRICE[7 ether] = 6;
LEVEL_PRICE[20 ether] = 7;
LEVEL_PRICE[60 ether] = 8;
SPONSOR[0.1 ether] = 0.027 ether;
SPONSOR[0.15 ether] = 0.105 ether;
SPONSOR[0.5 ether] = 0.35 ether;
SPONSOR[1.5 ether] = 1.05 ether;
SPONSOR[3.5 ether] = 2.45 ether;
SPONSOR[7 ether] = 4.9 ether;
SPONSOR[20 ether] = 14 ether;
SPONSOR[60 ether] = 42 ether;
INTRODUCER[0.1 ether] = 0.0315 ether;
INTRODUCER[0.15 ether] = 0.0225 ether;
INTRODUCER[0.5 ether] = 0.075 ether;
INTRODUCER[1.5 ether] = 0.225 ether;
INTRODUCER[3.5 ether] = 0.525 ether;
INTRODUCER[7 ether] = 1.05 ether;
INTRODUCER[20 ether] = 3 ether;
INTRODUCER[60 ether] = 9 ether;
UPLINE[0.1 ether] = 0.00504 ether;
UPLINE[0.15 ether] = 0.0036 ether;
UPLINE[0.5 ether] = 0.012 ether;
UPLINE[1.5 ether] = 0.036 ether;
UPLINE[3.5 ether] = 0.084 ether;
UPLINE[7 ether] = 0.168 ether;
UPLINE[20 ether] = 0.48 ether;
UPLINE[60 ether] = 1.44 ether;
FEE[0.1 ether] = 0.01 ether;
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist: true,
level: 18,
introducedTotal: 0,
referrerID: 0,
introducerID: 0,
wallet: main_address,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[currentUserID] = userStruct;
userList[main_address] = currentUserID;
}
function setMainAddress(address _main_address) public onlyOwner {
require(userList[_main_address] == 0, 'Address is already in use by another user');
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setAddress(address _main_address, address _upline_address) public onlyOwner {
Main_address = _main_address;
Upline_address = _upline_address;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
function getStats() public view onlyOwner returns(uint) {
return Stats;
}
function setLevelPrice(uint _price, uint _level) public onlyOwner {
LEVEL_PRICE[_price] = _level;
}
function setSponsor(uint _price, uint _sponsor) public onlyOwner {
SPONSOR[_price] = _sponsor;
}
function setIntroducer(uint _price, uint _introducer) public onlyOwner {
INTRODUCER[_price] = _introducer;
}
function setUpline(uint _price, uint _upline) public onlyOwner {
UPLINE[_price] = _upline;
}
function setFee(uint _price, uint _fee) public onlyOwner {
FEE[_price] = _fee;
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
currentUserID = _currentUserID;
}
function viewStats() public view onlyOwner returns(uint) {
return stats;
}
function addManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = true;
managers[manager_2] = true;
managers[manager_3] = true;
managers[manager_4] = true;
managers[manager_5] = true;
managers[manager_6] = true;
managers[manager_7] = true;
managers[manager_8] = true;
managers[manager_9] = true;
managers[manager_10] = true;
}
function removeManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = false;
managers[manager_2] = false;
managers[manager_3] = false;
managers[manager_4] = false;
managers[manager_5] = false;
managers[manager_6] = false;
managers[manager_7] = false;
managers[manager_8] = false;
managers[manager_9] = false;
managers[manager_10] = false;
}
function addManager(address manager) public onlyOwner {
managers[manager] = true;
}
function removeManager(address manager) public onlyOwner {
managers[manager] = false;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public {
require(msg.sender == owner || managers[msg.sender], "Only for owner");
require(_userID > 1, 'Invalid user ID');
require(_level > 0, 'Invalid level');
require(_introducedTotal >= 0, 'Invalid introduced total');
require(_wallet != address(0), 'Invalid user wallet');
if(_userID > 1){
require(_referrerID > 0, 'Invalid referrer ID');
require(_introducerID > 0, 'Invalid introducer ID');
}
if(_userID > currentUserID){
currentUserID++;
}
if(users[_userID].isExist){
delete userList[users[_userID].wallet];
delete users[_userID];
}
UserStruct memory userStruct;
userStruct = UserStruct({
isExist: true,
level: _level,
introducedTotal: _introducedTotal,
referrerID: _referrerID,
introducerID: _introducerID,
wallet: _wallet,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[_userID] = userStruct;
userList[_wallet] = _userID;
uint upline_2_id = users[users[_introducerID].introducerID].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(users[_introducerID].introducerID >0){
users[_userID].introducers.push(users[_introducerID].introducerID);
}
if(upline_2_id >0){
users[_userID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[_userID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[_userID].introducers.push(upline_4_id);
}
if(_referral1 != uint(0)){
users[_userID].referrals.push(_referral1);
}
if(_referral2 != uint(0)){
users[_userID].referrals.push(_referral2);
}
if(_referral3 != uint(0)){
users[_userID].referrals.push(_referral3);
}
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount');
if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist : true,
level: 1,
introducedTotal: 0,
referrerID : _referrerID,
introducerID : _introducerID,
wallet : msg.sender,
introducers: new uint[](0),
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
uint upline_1_id = users[_introducerID].introducerID;
uint upline_2_id = users[upline_1_id].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(upline_1_id >0){
users[currentUserID].introducers.push(upline_1_id);
}
if(upline_2_id >0){
users[currentUserID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[currentUserID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[currentUserID].introducers.push(upline_4_id);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
users[_referrerID].introducedTotal += 1;
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require(_level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
uint sponsor_id;
uint introducer_id = users[_user].introducerID;
uint money_left = msg.value;
if(FEE[msg.value] > 0){
address(uint160(Main_address)).transfer(FEE[msg.value]);
money_left = SafeMath.sub(money_left,FEE[msg.value]);
stats = SafeMath.add(stats,FEE[msg.value]);
}
if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){
sponsor_id = users[_user].referrerID;
} else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){
sponsor_id = users[users[_user].referrerID].referrerID;
} else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){
sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID;
} else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){
sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID;
}
stats_total = SafeMath.add(stats_total,msg.value);
if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){
if(users[_user].referrerID != 1){
emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
} else {
address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]);
money_left = SafeMath.sub(money_left,SPONSOR[msg.value]);
emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
if(users[introducer_id].isExist){
if(INTRODUCER[msg.value] > 0){
if(!users[introducer_id].isExist || users[introducer_id].level < _level){
if(introducer_id != 1){
emit Lost(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
} else {
address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]);
money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]);
emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
}
if(UPLINE[msg.value] > 0){
if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){
for (uint i=0; i<users[_user].introducers.length; i++) {
if(users[users[_user].introducers[i]].isExist && users[users[_user].introducers[i]].level >= _level && (users[users[_user].introducers[i]].introducedTotal >= SafeMath.add(i, uint(1)) || users[users[_user].introducers[i]].introducedTotal >= uint(3))){
address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]);
emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
money_left = SafeMath.sub(money_left,UPLINE[msg.value]);
} else {
emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
}
}
}
}
}
if(money_left > 0){
address(uint160(Upline_address)).transfer(money_left);
Stats = SafeMath.add(Stats,money_left);
}
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(users[_user].isExist, 'User does not exist');
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](363);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 120){
referrals[(i+1)*3] = users[referrals[i]].referrals[0];
referrals[(i+1)*3+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*3+2] = users[referrals[i]].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
return users[_user].referrals;
}
function viewUserIntroducers(uint _user) public view returns(uint[] memory) {
return users[_user].introducers;
}
function viewUserLevel(uint _user) public view returns(uint) {
return users[_user].level;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 163,228 | 11,835 |
a866f36e089c5c00fbaba49402bc62a4f8570dcac2fab61058a524e06f112ad5
| 20,069 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7b2f9706cd8473b4f5b7758b0171a9933fc6c4d6.sol
| 2,985 | 11,397 |
pragma solidity ^0.4.17;
contract ERC20 {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/// @dev Crowdsale interface for Etheal Normal Sale, functions needed from outside.
contract iEthealSale {
bool public paused;
uint256 public minContribution;
uint256 public whitelistThreshold;
mapping (address => uint256) public stakes;
function setPromoBonus(address _investor, uint256 _value) public;
function buyTokens(address _beneficiary) public payable;
function depositEth(address _beneficiary, uint256 _time, bytes _whitelistSign) public payable;
function depositOffchain(address _beneficiary, uint256 _amount, uint256 _time) public;
function hasEnded() public constant returns (bool);
}
contract HasNoTokens is Ownable {
event ExtractedTokens(address indexed _token, address indexed _claimer, uint _amount);
/// @notice This method can be used to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
/// @param _claimer Address that tokens will be send to
function extractTokens(address _token, address _claimer) onlyOwner public {
if (_token == 0x0) {
_claimer.transfer(this.balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(_claimer, balance);
ExtractedTokens(_token, _claimer, balance);
}
}
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 Token {
function totalSupply () view returns (uint256 supply);
function balanceOf (address _owner) view returns (uint256 balance);
function transfer (address _to, uint256 _value) returns (bool success);
function transferFrom (address _from, address _to, uint256 _value) returns (bool success);
function approve (address _spender, uint256 _value) returns (bool success);
function allowance (address _owner, address _spender) view returns (uint256 remaining);
event Transfer (address indexed _from, address indexed _to, uint256 _value);
event Approval (address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token {
using SafeMath for uint;
function AbstractToken () {
// Do nothing
}
function balanceOf (address _owner) view returns (uint256 balance) {
return accounts[_owner];
}
function transfer (address _to, uint256 _value) returns (bool success) {
uint256 fromBalance = accounts[msg.sender];
if (fromBalance < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts[msg.sender] = fromBalance.sub(_value);
accounts[_to] = accounts[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
return true;
}
function transferFrom (address _from, address _to, uint256 _value) returns (bool success) {
uint256 spenderAllowance = allowances[_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = accounts[_from];
if (fromBalance < _value) return false;
allowances[_from][msg.sender] = spenderAllowance.sub(_value);
if (_value > 0 && _from != _to) {
accounts[_from] = fromBalance.sub(_value);
accounts[_to] = accounts[_to].add(_value);
Transfer(_from, _to, _value);
}
return true;
}
function approve (address _spender, uint256 _value) returns (bool success) {
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance (address _owner, address _spender) view returns (uint256 remaining) {
return allowances[_owner][_spender];
}
mapping (address => uint256) accounts;
mapping (address => mapping (address => uint256)) private allowances;
}
contract AbstractVirtualToken is AbstractToken {
using SafeMath for uint;
uint256 constant MAXIMUM_TOKENS_COUNT = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 constant BALANCE_MASK = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 constant MATERIALIZED_FLAG_MASK = 0x8000000000000000000000000000000000000000000000000000000000000000;
function AbstractVirtualToken () {
// Do nothing
}
function totalSupply () view returns (uint256 supply) {
return tokensCount;
}
function balanceOf (address _owner) constant returns (uint256 balance) {
return (accounts[_owner] & BALANCE_MASK).add(getVirtualBalance(_owner));
}
function transfer (address _to, uint256 _value) returns (bool success) {
if (_value > balanceOf(msg.sender)) return false;
else {
materializeBalanceIfNeeded(msg.sender, _value);
return AbstractToken.transfer(_to, _value);
}
}
function transferFrom (address _from, address _to, uint256 _value) returns (bool success) {
if (_value > allowance(_from, msg.sender)) return false;
if (_value > balanceOf(_from)) return false;
else {
materializeBalanceIfNeeded(_from, _value);
return AbstractToken.transferFrom(_from, _to, _value);
}
}
function virtualBalanceOf (address _owner) internal view returns (uint256 _virtualBalance);
function getVirtualBalance (address _owner) private view returns (uint256 _virtualBalance) {
if (accounts [_owner] & MATERIALIZED_FLAG_MASK != 0) return 0;
else {
_virtualBalance = virtualBalanceOf(_owner);
uint256 maxVirtualBalance = MAXIMUM_TOKENS_COUNT.sub(tokensCount);
if (_virtualBalance > maxVirtualBalance)
_virtualBalance = maxVirtualBalance;
}
}
function materializeBalanceIfNeeded (address _owner, uint256 _value) private {
uint256 storedBalance = accounts[_owner];
if (storedBalance & MATERIALIZED_FLAG_MASK == 0) {
// Virtual balance is not materialized yet
if (_value > storedBalance) {
// Real balance is not enough
uint256 virtualBalance = getVirtualBalance(_owner);
require (_value.sub(storedBalance) <= virtualBalance);
accounts[_owner] = MATERIALIZED_FLAG_MASK | storedBalance.add(virtualBalance);
tokensCount = tokensCount.add(virtualBalance);
}
}
}
uint256 tokensCount;
}
contract EthealPromoToken is HasNoTokens, AbstractVirtualToken {
// Balance threshold to assign virtual tokens to the owner of higher balances then this threshold.
uint256 private constant VIRTUAL_THRESHOLD = 0.1 ether;
// Number of virtual tokens to assign to the owners of balances higher than virtual threshold.
uint256 private constant VIRTUAL_COUNT = 911;
// crowdsale to set bonus when sending token
iEthealSale public crowdsale;
// logging promo token activation
event LogBonusSet(address indexed _address, uint256 _amount);
////////////////
// Basic functions
////////////////
/// @dev Constructor, crowdsale address can be 0x0
function EthealPromoToken(address _crowdsale) {
crowdsale = iEthealSale(_crowdsale);
}
/// @dev Setting crowdsale, crowdsale address can be 0x0
function setCrowdsale(address _crowdsale) public onlyOwner {
crowdsale = iEthealSale(_crowdsale);
}
/// @notice Get virtual balance of the owner of given address.
/// @param _owner address to get virtual balance for the owner
/// @return virtual balance of the owner of given address
function virtualBalanceOf(address _owner) internal view returns (uint256) {
return _owner.balance >= VIRTUAL_THRESHOLD ? VIRTUAL_COUNT : 0;
}
/// @notice Get name of this token.
function name() public pure returns (string result) {
return "An Etheal Promo";
}
/// @notice Get symbol of this token.
function symbol() public pure returns (string result) {
return "HEALP";
}
/// @notice Get number of decimals for this token.
function decimals() public pure returns (uint8 result) {
return 0;
}
////////////////
// Set sale bonus
////////////////
/// @dev Internal function for setting sale bonus
function setSaleBonus(address _from, address _to, uint256 _value) internal {
if (address(crowdsale) == address(0)) return;
if (_value == 0) return;
if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) {
crowdsale.setPromoBonus(_from, _value);
LogBonusSet(_from, _value);
}
}
/// @dev Override transfer function to set sale bonus
function transfer(address _to, uint256 _value) public returns (bool) {
bool success = super.transfer(_to, _value);
if (success) {
setSaleBonus(msg.sender, _to, _value);
}
return success;
}
/// @dev Override transfer function to set sale bonus
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if (success) {
setSaleBonus(_from, _to, _value);
}
return success;
}
////////////////
// Extra
////////////////
/// @notice Notify owners about their virtual balances.
function massNotify(address[] _owners) public onlyOwner {
for (uint256 i = 0; i < _owners.length; i++) {
Transfer(address(0), _owners[i], VIRTUAL_COUNT);
}
}
/// @notice Kill this smart contract.
function kill() public onlyOwner {
selfdestruct(owner);
}
}
| 213,667 | 11,836 |
3261a7ee420df15f60fbb85ff9dd61c1511601d5200bf526384398babadbfbd6
| 30,780 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xe8B79104dC307879Dc707545Dc7E0b6E5C1554d6/contract.sol
| 4,039 | 16,591 |
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
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 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 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 _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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data,
"SafeBEP20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeBEP20: BEP20 operation did not succeed");
}
}
}
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view 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 Presale is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
uint256 private immutable _referrerFee = 3;
IBEP20 public token;
uint256 public immutable softCap;
uint256 public immutable hardCap;
uint256 public immutable tokensPerBnb;
uint256 public immutable minContribution;
uint256 public immutable maxContribution;
uint256 public immutable startTime;
uint256 public immutable endTime;
uint256 public weiRaised;
bool public finalized;
mapping(address => uint256) public tokenContributions;
mapping(address => uint256) public referrerContributions;
mapping(address => uint256) public totalContributions;
mapping(address => uint256) public refunds;
mapping(address => uint256) public referredTokens;
mapping(address => uint256) public claimedTokens;
mapping(address => address[]) public referredAddresses;
event TokenPurchase(address indexed beneficiary, uint256 weiAmount);
event TokenClaim(address indexed beneficiary, uint256 tokenAmount);
event Refund(address indexed beneficiary, uint256 weiAmount);
event PresaleFinalized(uint256 weiAmount);
constructor(IBEP20 _token,
uint256 _softCap,
uint256 _hardCap,
uint256 _tokensPerBnb,
uint256 _minContribution,
uint256 _maxContribution,
uint256 _startTime,
uint256 _endTime) public {
token = _token;
softCap = _softCap;
hardCap = _hardCap;
tokensPerBnb = _tokensPerBnb;
minContribution = _minContribution;
maxContribution = _maxContribution;
startTime = _startTime;
endTime = _endTime;
}
receive() external payable {
_buyTokens(msg.sender, address(0));
}
function contribute(address referrer) public payable {
require(referrer != msg.sender,
"EFutureCoinPresale: self referral not allowed");
_buyTokens(msg.sender, referrer);
}
function _buyTokens(address beneficiary, address referrer) internal {
uint256 weiToHardcap = hardCap.sub(weiRaised);
uint256 weiAmount = weiToHardcap < msg.value ? weiToHardcap : msg.value;
_buyTokens(beneficiary, referrer, weiAmount);
if (weiAmount < msg.value) {
uint256 refund = msg.value.sub(weiAmount);
payable(beneficiary).transfer(refund);
}
}
function _buyTokens(address beneficiary,
address referrer,
uint256 weiAmount) internal {
_validatePurchase(beneficiary, weiAmount);
weiRaised = weiRaised.add(weiAmount);
tokenContributions[beneficiary] = tokenContributions[beneficiary].add(weiAmount);
totalContributions[beneficiary] = totalContributions[beneficiary].add(weiAmount);
if (referrer != address(0)) {
uint256 referrerFeeAmount = weiAmount.mul(_referrerFee).div(10**2);
referrerContributions[referrer] = referrerContributions[referrer]
.add(referrerFeeAmount);
totalContributions[referrer] = totalContributions[referrer].add(referrerFeeAmount);
referredAddresses[referrer].push(beneficiary);
}
emit TokenPurchase(beneficiary, weiAmount);
}
function _validatePurchase(address beneficiary, uint256 weiAmount)
internal
view
{
require(isOpen(), "EFutureCoinPresale: sale is not open");
require(!hasEnded(), "EFutureCoinPresale: sale is over");
require(weiAmount >= minContribution,
"EFutureCoinPresale: min contribution criteria not met");
require(tokenContributions[beneficiary].add(weiAmount) <= maxContribution,
"EFutureCoinPresale: max contribution criteria not met");
this;
}
function claimTokens() external {
require(hasEnded(), "EFutureCoinPresale: sale is not over");
require(softCapReached(),
"EFutureCoinPresale: soft cap not reached, refund is available");
require(tokenContributions[msg.sender] > 0,
"EFutureCoinPresale: nothing to claim");
uint256 tokens = _getTokenAmount(totalContributions[msg.sender]);
referredTokens[msg.sender] = _getTokenAmount(referrerContributions[msg.sender]);
totalContributions[msg.sender] = 0;
tokenContributions[msg.sender] = 0;
referrerContributions[msg.sender] = 0;
claimedTokens[msg.sender] = tokens;
token.safeTransfer(msg.sender, tokens);
emit TokenClaim(msg.sender, tokens);
}
function claimRefund() external {
require(hasEnded(), "EFutureCoinPresale: sale is not over");
require(!softCapReached(),
"EFutureCoinPresale: soft cap reached, claimTokens is available");
require(tokenContributions[msg.sender] > 0,
"EFutureCoinPresale: nothing to claim");
uint256 refundAmount = tokenContributions[msg.sender];
totalContributions[msg.sender] = 0;
tokenContributions[msg.sender] = 0;
referrerContributions[msg.sender] = 0;
refunds[msg.sender] = refundAmount;
payable(msg.sender).transfer(refundAmount);
emit Refund(msg.sender, refundAmount);
}
function endPresale() external onlyOwner {
require(!finalized, "EFutureCoinPresale: sale is already over");
finalized = true;
if (weiRaised > softCap) {
uint256 totalWeiRaised = address(this).balance;
payable(owner()).transfer(totalWeiRaised);
}
emit PresaleFinalized(weiRaised);
}
function withdrawTokens() public onlyOwner {
require(finalized, "EFutureCoinPresale: sale is not over");
uint256 tokens = token.balanceOf(address(this));
token.transfer(owner(), tokens);
}
function _getTokenAmount(uint256 weiAmount)
internal
view
returns (uint256)
{
return weiAmount.mul(tokensPerBnb).div(1e18);
}
function getReferredAddresses(address referrerAddr)
public
view
returns (address[] memory)
{
return referredAddresses[referrerAddr];
}
function isOpen() public view returns (bool) {
return block.timestamp >= startTime && block.timestamp <= endTime;
}
function hasEnded() public view returns (bool) {
return finalized || now >= endTime || weiRaised >= hardCap;
}
function softCapReached() public view returns (bool) {
return weiRaised >= softCap;
}
}
| 249,619 | 11,837 |
ad055ccd925ef3fa4242626c58d96a4a23a148308a0ae3aadbf8eb10b8e45315
| 10,273 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x80fb784b7ed66730e8b1dbd9820afd29931aab03-LEND-EthLend.sol
| 2,641 | 9,879 |
pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
// Standard token interface (ERC 20)
// https://github.com/ethereum/EIPs/issues/20
contract Token is SafeMath {
// Functions:
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
function transfer(address _to, uint256 _value) returns(bool);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns(bool);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StdToken is Token {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public supply = 0;
// Functions:
function transfer(address _to, uint256 _value) returns(bool) {
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
return true;
}
function totalSupply() constant returns (uint256) {
return supply;
}
function balanceOf(address _owner) constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
}
contract EthLendToken is StdToken
{
/// Fields:
string public constant name = "EthLend Token";
string public constant symbol = "LEND";
uint public constant decimals = 18;
// this includes DEVELOPERS_BONUS
uint public constant TOTAL_SUPPLY = 1300000000 * (1 ether / 1 wei);
uint public constant DEVELOPERS_BONUS = 300000000 * (1 ether / 1 wei);
uint public constant PRESALE_PRICE = 30000; // per 1 Ether
uint public constant PRESALE_MAX_ETH = 2000;
// 60 mln tokens sold during presale
uint public constant PRESALE_TOKEN_SUPPLY_LIMIT = PRESALE_PRICE * PRESALE_MAX_ETH * (1 ether / 1 wei);
uint public constant ICO_PRICE1 = 27500; // per 1 Ether
uint public constant ICO_PRICE2 = 26250; // per 1 Ether
uint public constant ICO_PRICE3 = 25000; // per 1 Ether
// 1bln - this includes presale tokens
uint public constant TOTAL_SOLD_TOKEN_SUPPLY_LIMIT = 1000000000* (1 ether / 1 wei);
enum State{
Init,
Paused,
PresaleRunning,
PresaleFinished,
ICORunning,
ICOFinished
}
State public currentState = State.Init;
bool public enableTransfers = false;
address public teamTokenBonus = 0;
// Gathered funds can be withdrawn only to escrow's address.
address public escrow = 0;
// Token manager has exclusive priveleges to call administrative
// functions on this contract.
address public tokenManager = 0;
uint public presaleSoldTokens = 0;
uint public icoSoldTokens = 0;
uint public totalSoldTokens = 0;
/// Modifiers:
modifier onlyTokenManager()
{
require(msg.sender==tokenManager);
_;
}
modifier onlyInState(State state)
{
require(state==currentState);
_;
}
/// Events:
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
/// Functions:
/// @dev Constructor
/// @param _tokenManager Token manager address.
function EthLendToken(address _tokenManager, address _escrow, address _teamTokenBonus)
{
tokenManager = _tokenManager;
teamTokenBonus = _teamTokenBonus;
escrow = _escrow;
// send team bonus immediately
uint teamBonus = DEVELOPERS_BONUS;
balances[_teamTokenBonus] += teamBonus;
supply+= teamBonus;
assert(PRESALE_TOKEN_SUPPLY_LIMIT==60000000 * (1 ether / 1 wei));
assert(TOTAL_SOLD_TOKEN_SUPPLY_LIMIT==1000000000 * (1 ether / 1 wei));
}
function buyTokens() public payable
{
require(currentState==State.PresaleRunning || currentState==State.ICORunning);
if(currentState==State.PresaleRunning){
return buyTokensPresale();
}else{
return buyTokensICO();
}
}
function buyTokensPresale() public payable onlyInState(State.PresaleRunning)
{
// min - 1 ETH
require(msg.value >= (1 ether / 1 wei));
uint newTokens = msg.value * PRESALE_PRICE;
require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
presaleSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
function buyTokensICO() public payable onlyInState(State.ICORunning)
{
// min - 0.01 ETH
require(msg.value >= ((1 ether / 1 wei) / 100));
uint newTokens = msg.value * getPrice();
require(totalSoldTokens + newTokens <= TOTAL_SOLD_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
icoSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
function getPrice()constant returns(uint)
{
if(currentState==State.ICORunning){
if(icoSoldTokens<(200000000 * (1 ether / 1 wei))){
return ICO_PRICE1;
}
if(icoSoldTokens<(300000000 * (1 ether / 1 wei))){
return ICO_PRICE2;
}
return ICO_PRICE3;
}else{
return PRESALE_PRICE;
}
}
function setState(State _nextState) public onlyTokenManager
{
//setState() method call shouldn't be entertained after ICOFinished
require(currentState != State.ICOFinished);
currentState = _nextState;
// enable/disable transfers
//enable transfers only after ICOFinished, disable otherwise
enableTransfers = (currentState==State.ICOFinished);
}
function withdrawEther() public onlyTokenManager
{
if(this.balance > 0)
{
require(escrow.send(this.balance));
}
}
/// Overrides:
function transfer(address _to, uint256 _value) returns(bool){
require(enableTransfers);
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
require(enableTransfers);
return super.transferFrom(_from,_to,_value);
}
function approve(address _spender, uint256 _value) returns (bool) {
require(enableTransfers);
return super.approve(_spender,_value);
}
/// Setters/getters
function setTokenManager(address _mgr) public onlyTokenManager
{
tokenManager = _mgr;
}
// Default fallback function
function() payable
{
buyTokens();
}
}
| 247,450 | 11,838 |
a95787867f40b5a4f7e1c889a1b403f0aaa18b8155e4cba5373d1450c1e44cc5
| 19,476 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x887e1988f7d697df22aea1207a5e1831ad3065ef.sol
| 4,579 | 17,816 |
pragma solidity ^0.4.18; // solhint-disable-line
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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 ERC721 {
function approve(address _to, uint256 _tokenID) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenID) public view returns (address addr);
function takeOwnership(uint256 _tokenID) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenID) public;
function transfer(address _to, uint256 _tokenID) public;
event Transfer(address indexed from, address indexed to, uint256 tokenID); // solhint-disable-line
event Approval(address indexed owner, address indexed approved, uint256 tokenID);
function name() public pure returns (string);
function symbol() public pure returns (string);
}
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 Manageable is Ownable {
address public manager;
bool public contractLock;
event ManagerTransferred(address indexed previousManager, address indexed newManager);
event ContractLockChanged(address admin, bool state);
function Manageable() public {
manager = msg.sender;
contractLock = false;
}
modifier onlyManager() {
require(msg.sender == manager);
_;
}
modifier onlyAdmin() {
require((msg.sender == manager) || (msg.sender == owner));
_;
}
modifier isUnlocked() {
require(!contractLock);
_;
}
function transferManager(address newManager) public onlyAdmin {
require(newManager != address(0));
ManagerTransferred(manager, newManager);
manager = newManager;
}
function setContractLock(bool setting) public onlyAdmin {
contractLock = setting;
ContractLockChanged(msg.sender, setting);
}
function payout(address _to) public onlyOwner {
if (_to == address(0)) {
owner.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
function withdrawFunds(address _to, uint256 amount) public onlyOwner {
require(this.balance >= amount);
if (_to == address(0)) {
owner.transfer(amount);
} else {
_to.transfer(amount);
}
}
}
contract TokenLayer is ERC721, Manageable {
using SafeMath for uint256;
event TokenCreated(uint256 tokenId, bytes32 name, uint256 parentId, address owner);
event TokenDeleted(uint256 tokenId);
event TokenSold(uint256 tokenId, uint256 oldPrice,
uint256 newPrice, address prevOwner,
address winner, bytes32 name,
uint256 parentId);
event PriceChanged(uint256 tokenId, uint256 oldPrice, uint256 newPrice);
event ParentChanged(uint256 tokenId, uint256 oldParentId, uint256 newParentId);
event NameChanged(uint256 tokenId, bytes32 oldName, bytes32 newName);
event MetaDataChanged(uint256 tokenId, bytes32 oldMeta, bytes32 newMeta);
uint256 private constant DEFAULTPARENT = 123456789;
mapping (uint256 => Token) private tokenIndexToToken;
mapping (address => uint256) private ownershipTokenCount;
address public gameAddress;
address public parentAddr;
uint256 private totalTokens;
uint256 public devFee = 50;
uint256 public ownerFee = 200;
uint256[10] private chainFees = [10];
struct Token {
bool exists;
address approved;
address owner;
bytes32 metadata;
bytes32 name;
uint256 lastBlock;
uint256 parentId;
uint256 price;
}
modifier onlySystem() {
require((msg.sender == gameAddress) || (msg.sender == manager));
_;
}
function TokenLayer(address _gameAddress, address _parentAddr) public {
gameAddress = _gameAddress;
parentAddr = _parentAddr;
}
function implementsERC721() public pure returns (bool) {
return true;
}
function name() public pure returns (string) {
return "CryptoJintori";
}
function symbol() public pure returns (string) {
return "JapanToken";
}
function approve(address _to, uint256 _tokenId, address _from) public onlySystem {
_approve(_to, _tokenId, _from);
}
function approve(address _to, uint256 _tokenId) public isUnlocked {
_approve(_to, _tokenId, msg.sender);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function bundleToken(uint256 _tokenId) public view returns(uint256[8] _tokenData) {
Token storage token = tokenIndexToToken[_tokenId];
uint256[8] memory tokenData;
tokenData[0] = uint256(token.name);
tokenData[1] = token.parentId;
tokenData[2] = token.price;
tokenData[3] = uint256(token.owner);
tokenData[4] = _getNextPrice(_tokenId);
tokenData[5] = devFee+getChainFees(_tokenId);
tokenData[6] = uint256(token.approved);
tokenData[7] = uint256(token.metadata);
return tokenData;
}
function takeOwnership(uint256 _tokenId, address _to) public onlySystem {
_takeOwnership(_tokenId, _to);
}
function takeOwnership(uint256 _tokenId) public isUnlocked {
_takeOwnership(_tokenId, msg.sender);
}
function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 _totalTokens = totalSupply();
uint256 resultIndex = 0;
uint256 tokenId = 0;
uint256 tokenIndex = 0;
while (tokenIndex <= _totalTokens) {
if (exists(tokenId)) {
tokenIndex++;
if (tokenIndexToToken[tokenId].owner == _owner) {
result[resultIndex] = tokenId;
resultIndex++;
}
}
tokenId++;
}
return result;
}
}
function totalSupply() public view returns (uint256 total) {
return totalTokens;
}
function transfer(address _to, address _from, uint256 _tokenId) public onlySystem {
_checkThenTransfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public isUnlocked {
_checkThenTransfer(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public onlySystem {
_transferFrom(_from, _to, _tokenId);
}
function transferFrom(address _from, uint256 _tokenId) public isUnlocked {
_transferFrom(_from, msg.sender, _tokenId);
}
function createToken(uint256 _tokenId, address _owner,
bytes32 _name, uint256 _parentId,
uint256 _price, bytes32 _metadata) public onlyAdmin {
require(_price > 0);
require(_addressNotNull(_owner));
require(_tokenId == uint256(uint32(_tokenId)));
require(!exists(_tokenId));
totalTokens++;
Token memory _token = Token({
name: _name,
parentId: _parentId,
exists: true,
price: _price,
owner: _owner,
approved : 0,
lastBlock : block.number,
metadata : _metadata
});
tokenIndexToToken[_tokenId] = _token;
TokenCreated(_tokenId, _name, _parentId, _owner);
_transfer(address(0), _owner, _tokenId);
}
function createTokens(uint256[] _tokenIds, address[] _owners,
bytes32[] _names, uint256[] _parentIds,
uint256[] _prices, bytes32[] _metadatas) public onlyAdmin {
for (uint256 id = 0; id < _tokenIds.length; id++) {
createToken(_tokenIds[id], _owners[id], _names[id],
_parentIds[id], _prices[id], _metadatas[id]);
}
}
function deleteToken(uint256 _tokenId) public onlyAdmin {
require(_tokenId == uint256(uint32(_tokenId)));
require(exists(_tokenId));
totalTokens--;
address oldOwner = tokenIndexToToken[_tokenId].owner;
ownershipTokenCount[oldOwner] = ownershipTokenCount[oldOwner]--;
delete tokenIndexToToken[_tokenId];
TokenDeleted(_tokenId);
}
function incrementPrice(uint256 _tokenId, address _to) public onlySystem {
require(exists(_tokenId));
uint256 _price = tokenIndexToToken[_tokenId].price;
address _owner = tokenIndexToToken[_tokenId].owner;
uint256 _totalFees = getChainFees(_tokenId);
tokenIndexToToken[_tokenId].price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees));
TokenSold(_tokenId, _price, tokenIndexToToken[_tokenId].price,
_owner, _to, tokenIndexToToken[_tokenId].name,
tokenIndexToToken[_tokenId].parentId);
}
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
require(exists(_tokenId));
_owner = tokenIndexToToken[_tokenId].owner;
}
function blocked(uint256 _tokenId) public view returns (bool _blocked) {
return (tokenIndexToToken[_tokenId].lastBlock == block.number);
}
function exists(uint256 _tokenId) public view returns(bool) {
return (tokenIndexToToken[_tokenId].exists);
}
function setLayerParent(address _parent) public onlyAdmin {
parentAddr = _parent;
}
function setGame(address _gameAddress) public onlyAdmin {
gameAddress = _gameAddress;
}
function setPrice(uint256 _tokenId, uint256 _price, address _owner) public onlySystem {
require(_owns(_owner, _tokenId));
uint256 oldPrice = tokenIndexToToken[_tokenId].price;
tokenIndexToToken[_tokenId].price = _price;
PriceChanged(_tokenId, oldPrice, _price);
}
function setParent(uint256 _tokenId, uint256 _parentId) public onlyAdmin {
require(exists(_tokenId));
uint256 oldParentId = tokenIndexToToken[_tokenId].parentId;
tokenIndexToToken[_tokenId].parentId = _parentId;
ParentChanged(_tokenId, oldParentId, _parentId);
}
function setName(uint256 _tokenId, bytes32 _name) public onlyAdmin {
require(exists(_tokenId));
bytes32 oldName = tokenIndexToToken[_tokenId].name;
tokenIndexToToken[_tokenId].name = _name;
NameChanged(_tokenId, oldName, _name);
}
function setMetadata(uint256 _tokenId, bytes32 _metadata) public onlyAdmin {
require(exists(_tokenId));
bytes32 oldMeta = tokenIndexToToken[_tokenId].metadata;
tokenIndexToToken[_tokenId].metadata = _metadata;
MetaDataChanged(_tokenId, oldMeta, _metadata);
}
function setDevFee(uint256 _devFee) public onlyAdmin {
devFee = _devFee;
}
function setOwnerFee(uint256 _ownerFee) public onlyAdmin {
ownerFee = _ownerFee;
}
function setChainFees(uint256[10] _chainFees) public onlyAdmin {
chainFees = _chainFees;
}
function getToken(uint256 _tokenId) public view returns
(bytes32 tokenName, uint256 parentId, uint256 price,
address _owner, uint256 nextPrice, uint256 nextPriceFees,
address approved, bytes32 metadata) {
Token storage token = tokenIndexToToken[_tokenId];
tokenName = token.name;
parentId = token.parentId;
price = token.price;
_owner = token.owner;
nextPrice = _getNextPrice(_tokenId);
nextPriceFees = devFee+getChainFees(_tokenId);
metadata = token.metadata;
approved = token.approved;
}
function getChainFees(uint256 _tokenId) public view returns (uint256 _total) {
uint256 chainLength = _getChainLength(_tokenId);
uint256 totalFee = 0;
for (uint id = 0; id < chainLength; id++) {
totalFee = totalFee + chainFees[id];
}
return(totalFee);
}
function getChainFeeArray() public view returns (uint256[10] memory _chainFees) {
return(chainFees);
}
function getPriceOf(uint256 _tokenId) public view returns (uint256 price) {
require(exists(_tokenId));
return tokenIndexToToken[_tokenId].price;
}
function getParentOf(uint256 _tokenId) public view returns (uint256 parentId) {
require(exists(_tokenId));
return tokenIndexToToken[_tokenId].parentId;
}
function getMetadataOf(uint256 _tokenId) public view returns (bytes32 metadata) {
require(exists(_tokenId));
return (tokenIndexToToken[_tokenId].metadata);
}
function getChain(uint256 _tokenId) public view returns (address[10] memory _owners) {
require(exists(_tokenId));
uint256 _parentId = getParentOf(_tokenId);
address _parentAddr = parentAddr;
address[10] memory result;
if (_parentId != DEFAULTPARENT && _addressNotNull(_parentAddr)) {
uint256 resultIndex = 0;
TokenLayer layer = TokenLayer(_parentAddr);
bool parentExists = layer.exists(_parentId);
while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) {
parentExists = layer.exists(_parentId);
if (!parentExists) {
return(result);
}
result[resultIndex] = layer.ownerOf(_parentId);
resultIndex++;
_parentId = layer.getParentOf(_parentId);
_parentAddr = layer.parentAddr();
layer = TokenLayer(_parentAddr);
}
return(result);
}
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return (tokenIndexToToken[_tokenId].approved == _to);
}
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tokenIndexToToken[_tokenId].owner;
}
function _checkThenTransfer(address _from, address _to, uint256 _tokenId) private {
require(_owns(_from, _tokenId));
require(_addressNotNull(_to));
require(exists(_tokenId));
_transfer(_from, _to, _tokenId);
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
tokenIndexToToken[_tokenId].owner = _to;
tokenIndexToToken[_tokenId].lastBlock = block.number;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
tokenIndexToToken[_tokenId].approved = 0;
}
Transfer(_from, _to, _tokenId);
}
function _approve(address _to, uint256 _tokenId, address _from) private {
require(_owns(_from, _tokenId));
tokenIndexToToken[_tokenId].approved = _to;
Approval(_from, _to, _tokenId);
}
function _takeOwnership(uint256 _tokenId, address _to) private {
address newOwner = _to;
address oldOwner = tokenIndexToToken[_tokenId].owner;
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
function _transferFrom(address _from, address _to, uint256 _tokenId) private {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
function _getChainLength(uint256 _tokenId) private view returns (uint256 _length) {
uint256 length;
uint256 _parentId = getParentOf(_tokenId);
address _parentAddr = parentAddr;
if (_parentId == DEFAULTPARENT || !_addressNotNull(_parentAddr)) {
return 0;
}
TokenLayer layer = TokenLayer(_parentAddr);
bool parentExists = layer.exists(_parentId);
while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) {
parentExists = layer.exists(_parentId);
if(!parentExists) {
return(length);
}
_parentId = layer.getParentOf(_parentId);
_parentAddr = layer.parentAddr();
layer = TokenLayer(_parentAddr);
length++;
}
return(length);
}
function _getNextPrice(uint256 _tokenId) private view returns (uint256 _nextPrice) {
uint256 _price = tokenIndexToToken[_tokenId].price;
uint256 _totalFees = getChainFees(_tokenId);
_price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees));
return(_price);
}
}
| 145,477 | 11,839 |
67ad09aa528ac015ee339b5fcf0cc43b66c7016656d8ae85325913c2087406d8
| 16,090 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXb7ZeW4v4xwAyWcnj8wBT9TxnSeQhs3WV_TronCrown.sol
| 4,086 | 12,475 |
//SourceUnit: TronCrown.sol
pragma solidity 0.5.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TronCrown {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200 trx;
uint256 constant public BASE_PERCENT = 20;
uint256 constant public MAX_HOLD_PERCENT = 5;
uint256[] public REFERRAL_PERCENTS = [100,30, 20];
uint256 constant public MARKETING_FEE = 100;
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 24 hours;
uint256 constant public LEADER_BONUS_STEP=5;
uint256 constant public MAX_LEADER_PERCENT=5;
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 payable referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 refEarning;
uint256 match_bonus;
uint256 reinvested;
uint256 withdrawn;
}
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 payable referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT,"min amount is 200 Trx");
uint256 _amount=msg.value;
marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(_amount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, _amount.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 = _amount.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(_amount, 0, block.timestamp));
totalInvested = totalInvested.add(_amount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, _amount);
}
function ReInvest(address userAddress,uint256 amount) private {
// require(amount >= INVEST_MIN_AMOUNT,"min amount is 200 Trx");
User storage user = users[userAddress];
user.deposits.push(Deposit(amount, 0, block.timestamp));
totalInvested = totalInvested.add(amount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(userAddress, amount);
user.reinvested = user.reinvested.add(amount);
}
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(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(userPercentRate)).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(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(3)) {
dividends = (user.deposits[i].amount.mul(3)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
distributeRefBonus(msg.sender,totalAmount);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
user.refEarning = user.refEarning.add(referralBonus);
}
if(user.match_bonus>0){
totalAmount= totalAmount.add(user.match_bonus);
user.match_bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
require(contractBalance > totalAmount,"Contract Balance is lower");
user.withdrawn = user.withdrawn.add(totalAmount);
ReInvest(msg.sender,totalAmount.mul(40).div(100));
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount.mul(60).div(100));
totalWithdrawn = totalWithdrawn.add(totalAmount.mul(60).div(100));
emit Withdrawn(msg.sender, totalAmount.mul(60).div(100));
}
function distributeRefBonus(address userAddress,uint256 amount) private
{
for(uint256 i=0;i<10;i++)
{
address payable upline = users[userAddress].referrer;
if(upline!=address(0))
{
users[upline].match_bonus = users[upline].match_bonus.add(amount.mul(10).div(100));
userAddress = upline;
}
}
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier.add(getLeaderBonusRate(userAddress));
} else {
return getLeaderBonusRate(userAddress);
}
}
function getLeaderBonusRate(address userAddress) public view returns (uint) {
uint leaderBonusPercent = users[userAddress].level1.div(LEADER_BONUS_STEP);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint userPercentRate = BASE_PERCENT.add(getUserPercentRate(msg.sender));
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3)) {
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(3)) {
dividends = (user.deposits[i].amount.mul(3)).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) {
User memory _user=users[userAddress];
return (_user.level1, _user.level2, _user.level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return (users[userAddress].bonus);
}
function getUserMatchBonus(address userAddress) public view returns(uint256) {
return (users[userAddress].match_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 getUserReinvested(address userAddress) public view returns(uint256) {
return users[userAddress].reinvested;
}
function getUserRefEarnings(address userAddress) public view returns(uint256,uint256) {
return (users[userAddress].refEarning,users[userAddress].withdrawn);
}
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;
}
}
}
| 288,788 | 11,840 |
fbbc63d16efec1b0411db15d493ed40c55770f74eadc2cc0326dc96080b2b2f3
| 18,408 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x20719b298fe7c486a9dca33d10759a6f3f7e1db9.sol
| 4,726 | 17,808 |
pragma solidity ^0.4.24;
contract Token {
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function approve(address _spender, uint256 _value) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "msg.sender is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function transferTo(address _to) external onlyOwner returns (bool) {
require(_to != address(0), "Can't transfer to address 0x0");
owner = _to;
return true;
}
}
contract Oracle is Ownable {
uint256 public constant VERSION = 4;
event NewSymbol(bytes32 _currency);
mapping(bytes32 => bool) public supported;
bytes32[] public currencies;
function url() public view returns (string);
function getRate(bytes32 symbol, bytes data) public returns (uint256 rate, uint256 decimals);
function addCurrency(string ticker) public onlyOwner returns (bool) {
bytes32 currency = encodeCurrency(ticker);
emit NewSymbol(currency);
supported[currency] = true;
currencies.push(currency);
return true;
}
function encodeCurrency(string currency) public pure returns (bytes32 o) {
require(bytes(currency).length <= 32, "Currency too long");
assembly {
o := mload(add(currency, 32))
}
}
function decodeCurrency(bytes32 b) public pure returns (string o) {
uint256 ns = 256;
while (true) { if (ns == 0 || (b<<ns-8) != 0) break; ns -= 8; }
assembly {
ns := div(ns, 8)
o := mload(0x40)
mstore(0x40, add(o, and(add(add(ns, 0x20), 0x1f), not(0x1f))))
mstore(o, ns)
mstore(add(o, 32), b)
}
}
}
contract Engine {
uint256 public VERSION;
string public VERSION_NAME;
enum Status { initial, lent, paid, destroyed }
struct Approbation {
bool approved;
bytes data;
bytes32 checksum;
}
function getTotalLoans() public view returns (uint256);
function getOracle(uint index) public view returns (Oracle);
function getBorrower(uint index) public view returns (address);
function getCosigner(uint index) public view returns (address);
function ownerOf(uint256) public view returns (address owner);
function getCreator(uint index) public view returns (address);
function getAmount(uint index) public view returns (uint256);
function getPaid(uint index) public view returns (uint256);
function getDueTime(uint index) public view returns (uint256);
function getApprobation(uint index, address _address) public view returns (bool);
function getStatus(uint index) public view returns (Status);
function isApproved(uint index) public view returns (bool);
function getPendingAmount(uint index) public returns (uint256);
function getCurrency(uint index) public view returns (bytes32);
function cosign(uint index, uint256 cost) external returns (bool);
function approveLoan(uint index) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
function takeOwnership(uint256 index) public returns (bool);
function withdrawal(uint index, address to, uint256 amount) public returns (bool);
function identifierToIndex(bytes32 signature) public view returns (uint256);
}
contract Cosigner {
uint256 public constant VERSION = 2;
function url() public view returns (string);
function cost(address engine, uint256 index, bytes data, bytes oracleData) public view returns (uint256);
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool);
function claim(address engine, uint256 index, bytes oracleData) public returns (bool);
}
contract TokenConverter {
address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
function getReturn(Token _fromToken, Token _toToken, uint256 _fromAmount) external view returns (uint256 amount);
function convert(Token _fromToken, Token _toToken, uint256 _fromAmount, uint256 _minReturn) external payable returns (uint256 amount);
}
interface NanoLoanEngine {
function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool);
function rcn() public view returns (Token);
function getOracle(uint256 index) public view returns (Oracle);
function getAmount(uint256 index) public view returns (uint256);
function getCurrency(uint256 index) public view returns (bytes32);
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public view returns (uint256);
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
function getPendingAmount(uint256 index) public returns (uint256);
}
library LrpSafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
if (a < b) {
return a;
} else {
return b;
}
}
function max(uint256 a, uint256 b) internal pure returns(uint256) {
if (a > b) {
return a;
} else {
return b;
}
}
}
contract ConverterRamp is Ownable {
using LrpSafeMath for uint256;
address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
uint256 public constant AUTO_MARGIN = 1000001;
uint256 public constant I_MARGIN_SPEND = 0;
uint256 public constant I_MAX_SPEND = 1;
uint256 public constant I_REBUY_THRESHOLD = 2;
uint256 public constant I_ENGINE = 0;
uint256 public constant I_INDEX = 1;
uint256 public constant I_PAY_AMOUNT = 2;
uint256 public constant I_PAY_FROM = 3;
uint256 public constant I_LEND_COSIGNER = 2;
event RequiredRebuy(address token, uint256 amount);
event Return(address token, address to, uint256 amount);
event OptimalSell(address token, uint256 amount);
event RequiredRcn(uint256 required);
event RunAutoMargin(uint256 loops, uint256 increment);
function pay(TokenConverter converter,
Token fromToken,
bytes32[4] loanParams,
bytes oracleData,
uint256[3] convertRules) external payable returns (bool) {
Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn();
uint256 initialBalance = rcn.balanceOf(this);
uint256 requiredRcn = getRequiredRcnPay(loanParams, oracleData);
emit RequiredRcn(requiredRcn);
uint256 optimalSell = getOptimalSell(converter, fromToken, rcn, requiredRcn, convertRules[I_MARGIN_SPEND]);
emit OptimalSell(fromToken, optimalSell);
pullAmount(fromToken, optimalSell);
uint256 bought = convertSafe(converter, fromToken, rcn, optimalSell);
require(executeOptimalPay({
params: loanParams,
oracleData: oracleData,
rcnToPay: bought
}),
"Error paying the loan");
require(rebuyAndReturn({
converter: converter,
fromToken: rcn,
toToken: fromToken,
amount: rcn.balanceOf(this) - initialBalance,
spentAmount: optimalSell,
convertRules: convertRules
}),
"Error rebuying the tokens");
require(rcn.balanceOf(this) == initialBalance, "Converter balance has incremented");
return true;
}
function requiredLendSell(TokenConverter converter,
Token fromToken,
bytes32[3] loanParams,
bytes oracleData,
bytes cosignerData,
uint256[3] convertRules) external view returns (uint256) {
Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn();
return getOptimalSell(converter,
fromToken,
rcn,
getRequiredRcnLend(loanParams, oracleData, cosignerData),
convertRules[I_MARGIN_SPEND]);
}
function requiredPaySell(TokenConverter converter,
Token fromToken,
bytes32[4] loanParams,
bytes oracleData,
uint256[3] convertRules) external view returns (uint256) {
Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn();
return getOptimalSell(converter,
fromToken,
rcn,
getRequiredRcnPay(loanParams, oracleData),
convertRules[I_MARGIN_SPEND]);
}
function lend(TokenConverter converter,
Token fromToken,
bytes32[3] loanParams,
bytes oracleData,
bytes cosignerData,
uint256[3] convertRules) external payable returns (bool) {
Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn();
uint256 initialBalance = rcn.balanceOf(this);
uint256 requiredRcn = getRequiredRcnLend(loanParams, oracleData, cosignerData);
emit RequiredRcn(requiredRcn);
uint256 optimalSell = getOptimalSell(converter, fromToken, rcn, requiredRcn, convertRules[I_MARGIN_SPEND]);
emit OptimalSell(fromToken, optimalSell);
pullAmount(fromToken, optimalSell);
uint256 bought = convertSafe(converter, fromToken, rcn, optimalSell);
require(rcn.approve(address(loanParams[0]), bought), "Error approving lend token transfer");
require(executeLend(loanParams, oracleData, cosignerData), "Error lending the loan");
require(rcn.approve(address(loanParams[0]), 0), "Error removing approve");
require(executeTransfer(loanParams, msg.sender), "Error transfering the loan");
require(rebuyAndReturn({
converter: converter,
fromToken: rcn,
toToken: fromToken,
amount: rcn.balanceOf(this) - initialBalance,
spentAmount: optimalSell,
convertRules: convertRules
}),
"Error rebuying the tokens");
require(rcn.balanceOf(this) == initialBalance, "The contract balance should not change");
return true;
}
function pullAmount(Token token,
uint256 amount) private {
if (token == ETH_ADDRESS) {
require(msg.value >= amount, "Error pulling ETH amount");
if (msg.value > amount) {
msg.sender.transfer(msg.value - amount);
}
} else {
require(token.transferFrom(msg.sender, this, amount), "Error pulling Token amount");
}
}
function transfer(Token token,
address to,
uint256 amount) private {
if (token == ETH_ADDRESS) {
to.transfer(amount);
} else {
require(token.transfer(to, amount), "Error sending tokens");
}
}
function rebuyAndReturn(TokenConverter converter,
Token fromToken,
Token toToken,
uint256 amount,
uint256 spentAmount,
uint256[3] memory convertRules) internal returns (bool) {
uint256 threshold = convertRules[I_REBUY_THRESHOLD];
uint256 bought = 0;
if (amount != 0) {
if (amount > threshold) {
bought = convertSafe(converter, fromToken, toToken, amount);
emit RequiredRebuy(toToken, amount);
emit Return(toToken, msg.sender, bought);
transfer(toToken, msg.sender, bought);
} else {
emit Return(fromToken, msg.sender, amount);
transfer(fromToken, msg.sender, amount);
}
}
uint256 maxSpend = convertRules[I_MAX_SPEND];
require(spentAmount.safeSubtract(bought) <= maxSpend || maxSpend == 0, "Max spend exceeded");
return true;
}
function getOptimalSell(TokenConverter converter,
Token fromToken,
Token toToken,
uint256 requiredTo,
uint256 extraSell) internal returns (uint256 sellAmount) {
uint256 sellRate = (10 ** 18 * converter.getReturn(toToken, fromToken, requiredTo)) / requiredTo;
if (extraSell == AUTO_MARGIN) {
uint256 expectedReturn = 0;
uint256 optimalSell = applyRate(requiredTo, sellRate);
uint256 increment = applyRate(requiredTo / 100000, sellRate);
uint256 returnRebuy;
uint256 cl;
while (expectedReturn < requiredTo && cl < 10) {
optimalSell += increment;
returnRebuy = converter.getReturn(fromToken, toToken, optimalSell);
optimalSell = (optimalSell * requiredTo) / returnRebuy;
expectedReturn = returnRebuy;
cl++;
}
emit RunAutoMargin(cl, increment);
return optimalSell;
} else {
return applyRate(requiredTo, sellRate).safeMult(uint256(100000).safeAdd(extraSell)) / 100000;
}
}
function convertSafe(TokenConverter converter,
Token fromToken,
Token toToken,
uint256 amount) internal returns (uint256 bought) {
if (fromToken != ETH_ADDRESS) require(fromToken.approve(converter, amount), "Error approving token transfer");
uint256 prevBalance = toToken != ETH_ADDRESS ? toToken.balanceOf(this) : address(this).balance;
uint256 sendEth = fromToken == ETH_ADDRESS ? amount : 0;
uint256 boughtAmount = converter.convert.value(sendEth)(fromToken, toToken, amount, 1);
require(boughtAmount == (toToken != ETH_ADDRESS ? toToken.balanceOf(this) : address(this).balance) - prevBalance,
"Bought amound does does not match");
if (fromToken != ETH_ADDRESS) require(fromToken.approve(converter, 0), "Error removing token approve");
return boughtAmount;
}
function executeOptimalPay(bytes32[4] memory params,
bytes oracleData,
uint256 rcnToPay) internal returns (bool) {
NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE]));
uint256 index = uint256(params[I_INDEX]);
Oracle oracle = engine.getOracle(index);
uint256 toPay;
if (oracle == address(0)) {
toPay = rcnToPay;
} else {
uint256 rate;
uint256 decimals;
bytes32 currency = engine.getCurrency(index);
(rate, decimals) = oracle.getRate(currency, oracleData);
toPay = (rcnToPay * (10 ** (18 - decimals + (18 * 2)) / rate)) / 10 ** 18;
}
Token rcn = engine.rcn();
require(rcn.approve(engine, rcnToPay), "Error on payment approve");
require(engine.pay(index, toPay, address(params[I_PAY_FROM]), oracleData), "Error paying the loan");
require(rcn.approve(engine, 0), "Error removing the payment approve");
return true;
}
function executeLend(bytes32[3] memory params,
bytes oracleData,
bytes cosignerData) internal returns (bool) {
NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE]));
uint256 index = uint256(params[I_INDEX]);
return engine.lend(index, oracleData, Cosigner(address(params[I_LEND_COSIGNER])), cosignerData);
}
function executeTransfer(bytes32[3] memory params,
address to) internal returns (bool) {
return NanoLoanEngine(address(params[I_ENGINE])).transfer(to, uint256(params[1]));
}
function applyRate(uint256 amount,
uint256 rate) internal pure returns (uint256) {
return amount.safeMult(rate) / 10 ** 18;
}
function getRequiredRcnLend(bytes32[3] memory params,
bytes oracleData,
bytes cosignerData) internal view returns (uint256 required) {
NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE]));
uint256 index = uint256(params[I_INDEX]);
Cosigner cosigner = Cosigner(address(params[I_LEND_COSIGNER]));
if (cosigner != address(0)) {
required += cosigner.cost(engine, index, cosignerData, oracleData);
}
required += engine.convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, engine.getAmount(index));
}
function getRequiredRcnPay(bytes32[4] memory params,
bytes oracleData) internal view returns (uint256) {
NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE]));
uint256 index = uint256(params[I_INDEX]);
uint256 amount = uint256(params[I_PAY_AMOUNT]);
return engine.convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, amount);
}
function withdrawTokens(Token _token,
address _to,
uint256 _amount) external onlyOwner returns (bool) {
return _token.transfer(_to, _amount);
}
function withdrawEther(address _to,
uint256 _amount) external onlyOwner {
_to.transfer(_amount);
}
function() external payable {}
}
| 166,865 | 11,841 |
950d9ada42f58e89074d58c5f225ff98da095685b25c1846b736f41aca472763
| 27,647 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/56/56bd8ff5B8c08B476fF8493110a056C19195def9_PiggyBankStaking.sol
| 4,335 | 17,218 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using sPB via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using sPB via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsPiggyBank {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
interface ReferralBonus {
function getReferral(address _account) external view returns(address);
function getRefBonus() external view returns(uint256);
}
contract PiggyBankStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable PiggyBank;
address public immutable sPiggyBank;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _PiggyBank,
address _sPiggyBank,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_PiggyBank != address(0));
PiggyBank = _PiggyBank;
require(_sPiggyBank != address(0));
sPiggyBank = _sPiggyBank;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(PiggyBank).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsPiggyBank(sPiggyBank).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sPiggyBank).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsPiggyBank(sPiggyBank).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsPiggyBank(sPiggyBank).balanceForGons(info.gons));
IERC20(PiggyBank).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sPiggyBank).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(PiggyBank).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsPiggyBank(sPiggyBank).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsPiggyBank(sPiggyBank).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsPiggyBank(sPiggyBank).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(PiggyBank).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sPiggyBank).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sPiggyBank).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 92,258 | 11,842 |
27e9a0f7ff2edd32fa10a5bdc39a87101711c983cace1701c899d1f39e5da207
| 13,624 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd5abcc4c80fd01d8822f35f379fbcebf7a8b8679.sol
| 2,864 | 12,526 |
pragma solidity ^0.4.6;
/// @title Vault Contract
/// @author Jordi Baylina
/// @notice This contract holds funds for Campaigns and automates payments. For
/// this iteration the funds will come straight from the Giveth Multisig as a
/// safety precaution, but once fully tested and optimized this contract will
/// be a safe place to store funds equipped with optional variable time delays
/// to allow for an optional escape hatch
/// @dev `Owned` is a base level contract that assigns an `owner` that can be
/// later changed
contract Owned {
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner { if (msg.sender != owner) throw; _; }
address public owner;
/// @notice The Constructor assigns the message sender to be `owner`
function Owned() { owner = msg.sender;}
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner. 0x0 can be used to create
/// an unowned neutral vault, however that cannot be undone
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
}
/// @dev `Escapable` is a base level contract built off of the `Owned`
/// contract that creates an escape hatch function to send its ether to
/// `escapeDestination` when called by the `escapeCaller` in the case that
/// something unexpected happens
contract Escapable is Owned {
address public escapeCaller;
address public escapeDestination;
/// @notice The Constructor assigns the `escapeDestination` and the
/// `escapeCaller`
/// @param _escapeDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract
/// @param _escapeCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeDestination` it would be ideal that `escapeCaller` cannot move
/// funds out of `escapeDestination`
function Escapable(address _escapeCaller, address _escapeDestination) {
escapeDestination = _escapeDestination;
escapeCaller = _escapeCaller;
}
/// @dev The addresses preassigned the `escapeCaller` role
/// is the only addresses that can call a function with this modifier
modifier onlyEscapeCallerOrOwner {
if ((msg.sender != escapeCaller)&&(msg.sender != owner))
throw;
_;
}
/// @notice The `escapeHatch()` should only be called as a last resort if a
/// security issue is uncovered or something unexpected happened
function escapeHatch() onlyEscapeCallerOrOwner {
uint total = this.balance;
// Send the total balance of this contract to the `escapeDestination`
if (!escapeDestination.send(total)) {
throw;
}
EscapeCalled(total);
}
/// @notice Changes the address assigned to call `escapeHatch()`
/// @param _newEscapeCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeDestination` it would be ideal that `escapeCaller` cannot
/// move funds out of `escapeDestination`
function changeEscapeCaller(address _newEscapeCaller) onlyEscapeCallerOrOwner {
escapeCaller = _newEscapeCaller;
}
event EscapeCalled(uint amount);
}
/// @dev `Vault` is a higher level contract built off of the `Escapable`
/// contract that holds funds for Campaigns and automates payments.
contract Vault is Escapable {
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
string description; // What is the purpose of this payment
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint idPayment, address recipient, uint amount);
event PaymentExecuted(uint idPayment, address recipient, uint amount);
event PaymentCanceled(uint idPayment);
event EtherReceived(address from, uint amount);
event SpenderAuthorization(address spender, bool authorized);
/////////
// Constuctor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _escapeCaller The address of a trusted account or contract to
/// call `escapeHatch()` to send the ether in this contract to the
/// `escapeDestination` it would be ideal if `escapeCaller` cannot move
/// funds out of `escapeDestination`
/// @param _escapeDestination The address of a safe location (usu a
/// Multisig) to send the ether held in this contract in an emergency
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _securityGuard Address that will be able to delay the payments
/// beyond the initial timelock requirements; can be set to 0x0 to remove
/// the `securityGuard` functionality
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function Vault(address _escapeCaller,
address _escapeDestination,
uint _absoluteMinTimeLock,
uint _timeLock,
address _securityGuard,
uint _maxSecurityGuardDelay) Escapable(_escapeCaller, _escapeDestination)
{
securityGuard = _securityGuard;
timeLock = _timeLock;
absoluteMinTimeLock = _absoluteMinTimeLock;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
/// @notice States the total number of authorized payments in this contract
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _description Brief description of the payment that is authorized
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
function authorizePayment(string _description,
address _recipient,
uint _amount,
uint _paymentDelay) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender]) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
p.description = _description;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) throw;
if (!allowedSpenders[p.spender]) throw;
if (now < p.earliestPayTime) throw;
if (p.canceled) throw;
if (p.paid) throw;
if (this.balance < p.amount) throw;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
throw;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
| 148,448 | 11,843 |
da82ff7765bdf40ec6a40df5b0fa411d67601427b67adb2ab5edb11a96c3c1b5
| 13,731 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ae/Ae4799e0CA4C1AC972932a448D7F3dbB205Baf5B_MultiSigWallet.sol
| 2,984 | 12,969 |
pragma solidity ^0.5.17;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[emailprotected]>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
uint256 constant public MAX_OWNER_COUNT = 50;
mapping (uint256 => Transaction) public transactions;
mapping (uint256 => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
uint256 timestamp;
}
modifier onlyWallet() {
require(msg.sender == address(this), "Only wallet");
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner], "Owner exists");
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner], "Owner does not exists");
_;
}
modifier transactionExists(uint256 transactionId) {
require(transactions[transactionId].destination != address(0), "Tx doesn't exist");
_;
}
modifier confirmed(uint256 transactionId, address owner) {
require(confirmations[transactionId][owner], "not confirmed");
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
require(!confirmations[transactionId][owner], "is already confirmed");
_;
}
modifier notExecuted(uint256 transactionId) {
require(!transactions[transactionId].executed, "tx already executed");
_;
}
modifier notNull(address _address) {
require(_address != address(0), "address is null");
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
require(ownerCount <= MAX_OWNER_COUNT && _required <= ownerCount && _required != 0 && ownerCount != 0, "invalid requirement");
_;
}
/// @dev Fallback function allows to deposit ether.
function() external payable {
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners, uint256 _required) public validRequirement(_owners.length, _required) {
for (uint256 i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0), "is already owner");
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner to add.
function addOwner(address owner) public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to remove.
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner) public onlyWallet ownerExists(owner) ownerDoesNotExist(newOwner) {
for(uint256 i = 0; i < owners.length; i++) {
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint256 value, bytes memory data) public returns (uint256 transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId) public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId) public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint256 value, uint256 dataLength, bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint256 value, bytes memory data) internal
notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false,
timestamp: now
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) count += 1;
}
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
for (uint256 i = 0; i < transactionCount; i++) {
if (pending && !transactions[i].executed || executed && transactions[i].executed)
count += 1;
}
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint256 from, uint256 to, bool pending, bool executed) public view returns (uint256[] memory _transactionIds) {
uint256[] memory transactionIdsTemp = new uint256[](transactionCount);
uint256 count = 0;
uint256 i;
for (i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed || executed && transactions[i].executed) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint256[](to - from);
for (i = from; i < to; i++){
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
function getTransaction(uint256 transactionId) public view returns (bytes memory, address, bool, uint256) {
Transaction memory txn = transactions[transactionId];
return (txn.data,
txn.destination,
txn.executed,
txn.timestamp);
}
}
| 312,095 | 11,844 |
9636da9c54f2cbde50357c9b441c41fd2f7e638844d69da2800aa126e8401287
| 7,609 |
.sol
|
Solidity
| false |
548668394
|
kodiasteerforth/Learn-Solidity-in-2-hours
|
20c453539af9a32e30ab1078b0301b3b207acc36
|
LearnSolidity.sol
| 2,012 | 7,272 |
// Solidity is a high-level programming language used to implement smart contracts.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4; // Solidity version compiler
// Interface - Talking to other SC without needing to have the complete code on chain
interface IERC20 {
function transferFrom(address _from, address _to, uint256 _value) external returns(bool success);
}
contract learnSolidity { // start with contract keyword and arbitrary name
event Log(string message);
function deposit(address _tokenAddress, uint _amount) public { // Deposit function interface
IERC20(_tokenAddress).transferFrom(msg.sender, address(this), _amount);
}
// Data Types
string public myString = "My string";
string public age;
string public salute = "Hello World";
// Global Variables
function paySent() public payable {
require(msg.sender == tx.origin); // msg.sender = caller of function, tx.origin = origin of transaction
amount = msg.value; // Amount of ether sent alongside the transaction
}
// Other types
bool public boolean2 = false;
uint public myUint = 2;
int public myInt = -2;
address public myAddress = 0xeb9A114797953fC9DEb0f91168661d15Cfd5Fc34;
address private owner;
uint public amount;
// Arrays
uint[] public array = [2, 3, 4];
uint[] public array1;
uint[] public array2;
string[] public array3 = ["pear", "berries", "avocado"];
// Visibility in solidity
string private age1; // Only accesible inside the smart contract
string internal age2; // Accesible inside smart contract but can be inherited
string public age3; // Can be called inside/outside smart contract and also inherited
// function visiblity
function checkVisibility() public { // Can be called outside SC and called by another function
}
function checkVisibility1() private { // Cannot be called outside SC but can be called inside of another function in thesame SC
}
function checkVisibility2() external { // Can only be called outside the SC
}
function checkVisibility3() internal { // Can only be called inside the SM from another function
}
// function Modifiers
function checkAge() public view returns (string memory) { // View function can read the state of the blockchain but cannot modify state
return age;
}
function checkAge2() public pure returns(uint) { // Pure function cannot read the state of the blockchain nor modify state
return 2;
}
function acceptPayment() public payable { // Payable functions are allowed to receive ether whenever transaction is submitted
msg.value > tx.gasprice;
}
// Custom modifiers
modifier onlyOwner { // This restricts who can call a specific function reserved for the owner
require(msg.sender == owner, 'caller must be owner');
_;
}
// special function 'Constructor' is only called once whenever contract is put on the blockchain
constructor(string memory _age) {
age = _age;
}
// There are two types of functions in solidity write functions and read functions
function setValue(string memory _age) public { // This is a write function so you have to pay a gas fee to call function
age = _age;
}
function getValue() public view returns (string memory) { // While with the read function is completely free
return age;
}
// Operators in solidity
function eq(uint q, uint w) external pure returns(bool) { // Equal
return q == w;
}
function notEq(uint q, uint w) external pure returns(bool) { // Not Equal
return q != w;
}
function gT(uint q, uint w) external pure returns(bool) { // Greater than
return q > w;
}
function lT(uint q, uint w) external pure returns(bool) { // Less than
return q < w;
}
function gTEq2(uint q, uint w) external pure returns(bool) { // Greater than Equal to
return q >= w;
}
function lTEq2(uint q, uint w) external pure returns(bool) { // Less than Equal to
return q <= w;
}
function add(uint q, uint w) external pure returns(uint) { // Addition
return q + w;
}
function sub(uint q, uint w) external pure returns(uint) { // Subtraction
return q - w;
}
function div(uint q, uint w) external pure returns(uint) { // Division
return q / w;
}
function mul(uint q, uint w) external pure returns(uint) { // Multiplication
return q * w;
}
function exp(uint q, uint w) external pure returns(uint) { // Exponents
return q ** w;
}
function mod(uint q, uint w) external pure returns(uint) { // Modulus
return q % w;
}
function xor(uint q, uint w) external pure returns(uint) { // Bitwise Xor
return q ^ w;
}
function inc(uint q) external pure returns(uint) { // Increment
q++;
return q;
}
function dec(uint q) external pure returns(uint) { // Decrement
q--;
return q;
}
function and(bool q, bool w) external pure returns(bool) { // And making sure both things are true
return q && w;
}
function or(bool q, bool w) external pure returns(bool) { // Or either one of the variables is true
return q || w;
}
function not(bool q) external pure returns(bool) { // Check if something is not true
return !q;
}
function addExample() external pure returns(bool) {
return (1+1 == 2) && (2+2 == 4);
}
// Conditionals in Solidity
function evenOrOdd(uint q) public pure returns (string memory) {
if(q % 2 == 0) { // if q % 2 == 0 return 'even', else return 'odd'
return "even";
} else {
return "odd";
}
}
function evenOrOdd1(uint q) public pure returns (string memory) {
if(q % 2 == 0) {
return "even";
}
return "odd";
}
function evenOrOdd2(uint q) public pure returns (string memory) {
return q % 2 == 0 ? "even" : "odd";
}
// Mappings - Key value pairs used to store information inside SC
mapping(uint => address) public accountBalance;
mapping(uint => string) public name;
mapping(address => uint) public addresses;
mapping(address => bool) public hasVoted;
mapping(address => mapping(uint => bool)) public myMapping; // Nested mapping - mapping inside a mapping
// Structs - Lets you create your own types
struct structPacking {
uint32 a;
uint32 b;
uint16 c;
uint16 d;
}
// Ether - Native currency of the ethereum blockchain
uint public value1 = 1 wei;
uint public value2 = 2;
uint public value3 = 1 gwei;
uint public value4 = 1000000000;
uint public value5 = 1 ether;
uint public value6 = 1000000000000000000;
receive() external payable{} // Can receive ether directly via a SC if you call it external payable
function checkBalance() public view returns (uint) { // Can check balance of any address in SC like this
return address(this).balance;
}
function transfer(address payable _to) public payable { // Sending ether to an address
(bool sent,) = _to.call{value: msg.value}("");
require(sent, "Failed!");
}
// Error Handling
function example1(uint _amount) public {
require(_amount > 10, "must be greater than 10");
emit Log("success");
}
function example2(uint _amount) public {
if(_amount <= 10) {
revert("must be greater than 10");
}
emit Log("success");
}
// Events - Lets you subscribe externally to know whenever something has been called
event SaluteUpdated(address indexed _user,
string _salute);
function updateSalute(string memory _salute) public {
salute = _salute;
emit SaluteUpdated(msg.sender, _salute); // Trigger event with the emit keyword
}
}
| 337,263 | 11,845 |
65fc0cbb7eef3fa9fbd5ec4c8df2a9421017248357188e9a09017aaf4a30e340
| 15,291 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00cda8abd8a7193f69a1d54129ccd0b1fe61e53c.sol
| 3,767 | 13,452 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
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 DAIKOKU 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 = 1_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 = "DAIKOKU";
string private constant _symbol = "DAIKOKU";
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 public _maxTxAmount = 20_000 * 10**8;
uint256 public _maxWalletSize = 20_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=4;
_finalTax=2;
_reduceTaxCountdown=60;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = (_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<30) {
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 addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function 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);
}
}
| 343,861 | 11,846 |
8b5dc17e2b73ba9a472e01020007c2240ac77add2b177800de5988bec1cc9d14
| 15,426 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPVYdyQpqAdJdaGu1JkubRspbUCoHWzbLr_TronHighway.sol
| 3,579 | 13,898 |
//SourceUnit: TronHighway.sol
pragma solidity 0.5.14;
contract TronHighway {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 200;
uint constant public INVEST_MIN_AMOUNT = 200 trx;
uint constant public BASE_PERCENT = 500;
uint constant private FUND_FEE = 1500;
uint constant public MAX_CONTRACT_PERCENT = 1500;
uint constant public MAX_HOLD_PERCENT = 1000;
uint constant public MAX_DEPOSIT_PERCENT = 1500;
uint constant public MAX_BALANCE_BONUS_PERCENT = 1000;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 250000 trx;
uint constant public TIME_STEP = 1 days;
uint[] public REFERRAL_PERCENTS = [500, 400, 300, 200, 100];
uint public totalDeposits;
uint public totalInvested;
uint public totalWithdrawn;
uint public contractPercent;
address payable public fundAddress;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[5] refs;
uint16 rbackPercent;
}
mapping (address => User) internal users;
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 fundAddr) public {
require(!isContract(fundAddr));
fundAddress = fundAddr;
contractPercent = getContractBalanceRate();
}
function invest(address referrer) public payable {
require(!isContract(msg.sender));
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 200 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 200 deposits from address");
uint fundFee = msg.value.mul(FUND_FEE).div(PERCENTS_DIVIDER);
fundAddress.transfer(fundFee);
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 5; i++) {
if (upline != address(0)) {
uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (i == 0 && users[upline].rbackPercent > 0) {
refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
msg.sender.transfer(refbackAmount);
emit RefBack(upline, msg.sender, refbackAmount);
amount = amount.sub(refbackAmount);
}
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).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(msg.value), 0, uint64(refbackAmount), uint32(block.timestamp)));
totalInvested = totalInvested.add(msg.value);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
contractPercent = getContractBalanceRate();
emit Withdrawn(msg.sender, totalAmount);
}
function setRefback(uint16 rbackPercent) public {
require(rbackPercent <= 10000);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
user.rbackPercent = rbackPercent;
}
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < MAX_CONTRACT_PERCENT) {
return contractBalancePercent;
} else {
return MAX_CONTRACT_PERCENT;
}
}
function getContractBalanceBonusRate() public view returns (uint){
uint contractBalance = address(this).balance;
uint contractBalanceBonusRate = contractBalance.div(CONTRACT_BALANCE_STEP).mul(20);
if (contractBalanceBonusRate < MAX_BALANCE_BONUS_PERCENT) {
return contractBalanceBonusRate;
} else {
return MAX_BALANCE_BONUS_PERCENT;
}
}
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).mul(20);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
if(contractPercent.add(timeMultiplier) > MAX_CONTRACT_PERCENT){
return MAX_CONTRACT_PERCENT;
}else{
return contractPercent.add(timeMultiplier);
}
} else {
return contractPercent;
}
}
function getUserHoldBonusRate(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).mul(20);
if(timeMultiplier < MAX_HOLD_PERCENT){
return timeMultiplier;
}else {
return MAX_HOLD_PERCENT;
}
}else {
return 0;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function 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)).add(uint(user.deposits[i].refback));
}
return amount;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
uint contractBalanceBonusRate = getContractBalanceBonusRate();
return (totalInvested, totalDeposits, address(this).balance, contractBalanceBonusRate);
}
function getUserStats(address userAddress) public view returns (uint, 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);
uint userHoldBonusRate = getUserHoldBonusRate(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn, userHoldBonusRate);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint16, uint16, uint64, uint24[5] memory) {
User storage user = users[userAddress];
return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
}
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;
}
}
| 297,867 | 11,847 |
9fc7630aae6047e9af4d3182a5389a7e192fcbee5aa40307ae99495def5bd028
| 18,582 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb9131e894259d0d374bf189ca640ffc472a7d143.sol
| 4,577 | 17,200 |
pragma solidity ^0.4.11;
contract SafeMath {
function mul(uint a, uint b) constant internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) constant internal 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) constant internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) constant internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
// Volume bonus calculation
function volumeBonus(uint etherValue) constant internal returns (uint) {
if(etherValue >= 500000000000000000000) return 10; // 500 ETH +10% tokens
if(etherValue >= 300000000000000000000) return 7; // 300 ETH +7% tokens
if(etherValue >= 100000000000000000000) return 5; // 100 ETH +5% tokens
if(etherValue >= 50000000000000000000) return 3; // 50 ETH +3% tokens
if(etherValue >= 20000000000000000000) return 2; // 20 ETH +2% tokens
if(etherValue >= 10000000000000000000) return 1; // 10 ETH +1% tokens
return 0;
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
function totalSupply() constant returns (uint) {}
function balanceOf(address owner) constant returns (uint balance);
function transfer(address to, uint value) returns (bool success);
function transferFrom(address from, address to, uint value) returns (bool success);
function approve(address spender, uint value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint remaining);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Issuance(address indexed to, uint value);
}
contract IcoLimits {
uint constant privateSaleStart = 1511136000; // 11/20/2017 @ 12:00am (UTC)
uint constant privateSaleEnd = 1512086399; // 11/30/2017 @ 11:59pm (UTC)
uint constant presaleStart = 1512086400; // 12/01/2017 @ 12:00am (UTC)
uint constant presaleEnd = 1513900799; // 12/21/2017 @ 11:59pm (UTC)
uint constant publicSaleStart = 1516320000; // 01/19/2018 @ 12:00am (UTC)
uint constant publicSaleEnd = 1521158399; // 03/15/2018 @ 11:59pm (UTC)
modifier afterPublicSale() {
require(now > publicSaleEnd);
_;
}
uint constant privateSalePrice = 4000; // SNEK tokens per 1 ETH
uint constant preSalePrice = 3000; // SNEK tokens per 1 ETH
uint constant publicSalePrice = 2000; // SNEK tokens per 1 ETH
uint constant privateSaleSupplyLimit = 600 * privateSalePrice * 1000000000000000000;
uint constant preSaleSupplyLimit = 1200 * preSalePrice * 1000000000000000000;
uint constant publicSaleSupplyLimit = 5000 * publicSalePrice * 1000000000000000000;
}
contract StandardToken is AbstractToken, IcoLimits {
mapping (address => uint) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
address[] public owners;
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint _value) afterPublicSale returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint _value) afterPublicSale returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract ExoTownToken is StandardToken, SafeMath {
string public constant name = "ExoTown token";
string public constant symbol = "SNEK";
uint public constant decimals = 18;
address public icoContract = 0x0;
modifier onlyIcoContract() {
// only ICO contract is allowed to proceed
require(msg.sender == icoContract);
_;
}
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function ExoTownToken(address _icoContract) {
require(_icoContract != 0x0);
icoContract = _icoContract;
}
/// @dev Burns tokens from address. It can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
require(_value > 0);
balances[_from] = sub(balances[_from], _value);
totalSupply -= _value;
}
/// @dev Adds tokens to address. It can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
require(totalSupply + _value >= totalSupply);
balances[_to] = add(balances[_to], _value);
totalSupply += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(0x0, _to, _value);
}
function getOwner(uint index) constant returns (address, uint) {
return (owners[index], balances[owners[index]]);
}
function getOwnerCount() constant returns (uint) {
return owners.length;
}
}
contract ExoTownIco is SafeMath, IcoLimits {
ExoTownToken public exotownToken;
enum State {
Pause,
Running
}
State public currentState = State.Pause;
uint public privateSaleSoldTokens = 0;
uint public preSaleSoldTokens = 0;
uint public publicSaleSoldTokens = 0;
uint public privateSaleEtherRaised = 0;
uint public preSaleEtherRaised = 0;
uint public publicSaleEtherRaised = 0;
// Address of manager
address public icoManager;
address public founderWallet;
// Address from which tokens could be burned
address public buyBack;
// Purpose
address public developmentWallet;
address public marketingWallet;
address public teamWallet;
address public bountyOwner;
// Mediator wallet is used for tracking user payments and reducing users' fee
address public mediatorWallet;
bool public sentTokensToBountyOwner = false;
bool public sentTokensToFounders = false;
modifier whenInitialized() {
// only when contract is initialized
require(currentState >= State.Running);
_;
}
modifier onlyManager() {
// only ICO manager can do this action
require(msg.sender == icoManager);
_;
}
modifier onIco() {
require(isPrivateSale() || isPreSale() || isPublicSale());
_;
}
modifier hasBountyCampaign() {
require(bountyOwner != 0x0);
_;
}
function isPrivateSale() constant internal returns (bool) {
return now >= privateSaleStart && now <= privateSaleEnd;
}
function isPreSale() constant internal returns (bool) {
return now >= presaleStart && now <= presaleEnd;
}
function isPublicSale() constant internal returns (bool) {
return now >= publicSaleStart && now <= publicSaleEnd;
}
function getPrice() constant internal returns (uint) {
if (isPrivateSale()) return privateSalePrice;
if (isPreSale()) return preSalePrice;
if (isPublicSale()) return publicSalePrice;
return publicSalePrice;
}
function getStageSupplyLimit() constant returns (uint) {
if (isPrivateSale()) return privateSaleSupplyLimit;
if (isPreSale()) return preSaleSupplyLimit;
if (isPublicSale()) return publicSaleSupplyLimit;
return 0;
}
function getStageSoldTokens() constant returns (uint) {
if (isPrivateSale()) return privateSaleSoldTokens;
if (isPreSale()) return preSaleSoldTokens;
if (isPublicSale()) return publicSaleSoldTokens;
return 0;
}
function addStageTokensSold(uint _amount) internal {
if (isPrivateSale()) privateSaleSoldTokens = add(privateSaleSoldTokens, _amount);
if (isPreSale()) preSaleSoldTokens = add(preSaleSoldTokens, _amount);
if (isPublicSale()) publicSaleSoldTokens = add(publicSaleSoldTokens, _amount);
}
function addStageEtherRaised(uint _amount) internal {
if (isPrivateSale()) privateSaleEtherRaised = add(privateSaleEtherRaised, _amount);
if (isPreSale()) preSaleEtherRaised = add(preSaleEtherRaised, _amount);
if (isPublicSale()) publicSaleEtherRaised = add(publicSaleEtherRaised, _amount);
}
function getStageEtherRaised() constant returns (uint) {
if (isPrivateSale()) return privateSaleEtherRaised;
if (isPreSale()) return preSaleEtherRaised;
if (isPublicSale()) return publicSaleEtherRaised;
return 0;
}
function getTokensSold() constant returns (uint) {
return
privateSaleSoldTokens +
preSaleSoldTokens +
publicSaleSoldTokens;
}
function getEtherRaised() constant returns (uint) {
return
privateSaleEtherRaised +
preSaleEtherRaised +
publicSaleEtherRaised;
}
/// @dev Constructor of ICO. Requires address of icoManager,
/// @param _icoManager Address of ICO manager
function ExoTownIco(address _icoManager) {
require(_icoManager != 0x0);
exotownToken = new ExoTownToken(this);
icoManager = _icoManager;
}
/// Initialises addresses of founder, target wallets
/// @param _founder Address of Founder
/// @param _dev Address of Development wallet
/// @param _pr Address of Marketing wallet
/// @param _team Address of Team wallet
/// @param _buyback Address of wallet used for burning tokens
/// @param _mediator Address of Mediator wallet
function init(address _founder,
address _dev,
address _pr,
address _team,
address _buyback,
address _mediator) onlyManager {
require(currentState == State.Pause);
require(_founder != 0x0);
require(_dev != 0x0);
require(_pr != 0x0);
require(_team != 0x0);
require(_buyback != 0x0);
require(_mediator != 0x0);
founderWallet = _founder;
developmentWallet = _dev;
marketingWallet = _pr;
teamWallet = _team;
buyBack = _buyback;
mediatorWallet = _mediator;
currentState = State.Running;
exotownToken.emitTokens(icoManager, 0);
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager {
currentState = _newState;
}
/// @dev Sets new manager. Only manager can do it
/// @param _newIcoManager Address of new ICO manager
function setNewManager(address _newIcoManager) onlyManager {
require(_newIcoManager != 0x0);
icoManager = _newIcoManager;
}
/// @dev Sets bounty owner. Only manager can do it
/// @param _bountyOwner Address of Bounty owner
function setBountyCampaign(address _bountyOwner) onlyManager {
require(_bountyOwner != 0x0);
bountyOwner = _bountyOwner;
}
/// @dev Sets new Mediator wallet. Only manager can do it
/// @param _mediator Address of Mediator wallet
function setNewMediator(address _mediator) onlyManager {
require(_mediator != 0x0);
mediatorWallet = _mediator;
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
require(_buyer != 0x0);
require(msg.value > 0);
uint tokensToEmit = msg.value * getPrice();
uint volumeBonusPercent = volumeBonus(msg.value);
if (volumeBonusPercent > 0) {
tokensToEmit = mul(tokensToEmit, 100 + volumeBonusPercent) / 100;
}
uint stageSupplyLimit = getStageSupplyLimit();
uint stageSoldTokens = getStageSoldTokens();
require(add(stageSoldTokens, tokensToEmit) <= stageSupplyLimit);
exotownToken.emitTokens(_buyer, tokensToEmit);
// Public statistics
addStageTokensSold(tokensToEmit);
addStageEtherRaised(msg.value);
distributeEtherByStage();
}
/// @dev Buy tokens to specified wallet
function giftToken(address _to) public payable onIco {
buyTokens(_to);
}
/// @dev Fall back function
function () payable onIco {
buyTokens(msg.sender);
}
function distributeEtherByStage() private {
uint _balance = this.balance;
uint _balance_div = _balance / 100;
uint _devAmount = _balance_div * 65;
uint _prAmount = _balance_div * 25;
uint total = _devAmount + _prAmount;
if (total > 0) {
// Top up Mediator wallet with 1% of Development amount = 0.65% of contribution amount.
// It will cover tracking transaction fee (if any).
// See White Paper for more information about payment tracking
uint _mediatorAmount = _devAmount / 100;
mediatorWallet.transfer(_mediatorAmount);
developmentWallet.transfer(_devAmount - _mediatorAmount);
marketingWallet.transfer(_prAmount);
teamWallet.transfer(_balance - _devAmount - _prAmount);
}
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
require(_value > 0);
require(_value <= this.balance);
// send 1234 to get 1.234
icoManager.transfer(_value * 1000000000000000); // 10^15
}
function sendTokensToBountyOwner() onlyManager whenInitialized hasBountyCampaign afterPublicSale {
require(!sentTokensToBountyOwner);
//Calculate bounty tokens depending on total tokens sold
uint bountyTokens = getTokensSold() / 40; // 2.5%
exotownToken.emitTokens(bountyOwner, bountyTokens);
sentTokensToBountyOwner = true;
}
/// @dev Send tokens to founders.
function sendTokensToFounders() onlyManager whenInitialized afterPublicSale {
require(!sentTokensToFounders);
//Calculate founder reward depending on total tokens sold
uint founderReward = getTokensSold() / 10; // 10%
exotownToken.emitTokens(founderWallet, founderReward);
sentTokensToFounders = true;
}
// Anyone could burn tokens by sending it to buyBack address and calling this function.
function burnTokens(uint _amount) afterPublicSale {
exotownToken.burnTokens(buyBack, _amount);
}
}
| 140,440 | 11,848 |
a34a287b3882fc1707ae5143dccdbff26cf069b50d19f322e48536746498814b
| 31,821 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cf/cFEC71a2A53cCc9a543322bd80fEd796a7cf41A6_Masonry.sol
| 4,859 | 18,672 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getGhostPrice() 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 ghost;
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 _ghost,
IERC20 _share,
ITreasury _treasury) public notInitialized {
ghost = _ghost;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 3; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 1; // 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 getGhostPrice() external view returns (uint256) {
return treasury.getGhostPrice();
}
// =========== 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;
ghost.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);
ghost.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(ghost), "ghost");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 71,489 | 11,849 |
9ebc011c5360b7bae004e95dab42767bc0aa3dd8c844efa344ba20fb48a64bfd
| 20,636 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Exchange/0x818E6FECD516Ecc3849DAf6845e3EC868087B755.sol
| 4,476 | 18,815 |
pragma solidity 0.4.18;
// File: contracts/ERC20Interface.sol
// https://github.com/ethereum/EIPs/issues/20
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/KyberNetworkInterface.sol
/// @title Kyber Network interface
interface KyberNetworkInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(address trader, ERC20 src, uint srcAmount, ERC20 dest, address destAddress,
uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
}
// File: contracts/KyberNetworkProxyInterface.sol
/// @title Kyber Network interface
interface KyberNetworkProxyInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount,
uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
}
// File: contracts/SimpleNetworkInterface.sol
/// @title simple interface for Kyber Network
interface SimpleNetworkInterface {
function swapTokenToToken(ERC20 src, uint srcAmount, ERC20 dest, uint minConversionRate) public returns(uint);
function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint);
function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint);
}
// File: contracts/Utils.sol
/// @title Kyber constants contract
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
// File: contracts/Utils2.sol
contract Utils2 is Utils {
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
function getDecimalsSafe(ERC20 token) internal returns(uint) {
if (decimals[token] == 0) {
setDecimals(token);
}
return decimals[token];
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
internal pure returns(uint)
{
require(srcAmount <= MAX_QTY);
require(destAmount <= MAX_QTY);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
}
}
}
// File: contracts/PermissionGroups.sol
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
// File: contracts/Withdrawable.sol
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
// File: contracts/KyberNetworkProxy.sol
/// @title Kyber Network proxy for main contract
contract KyberNetworkProxy is KyberNetworkProxyInterface, SimpleNetworkInterface, Withdrawable, Utils2 {
KyberNetworkInterface public kyberNetworkContract;
function KyberNetworkProxy(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
bytes memory hint;
return tradeWithHint(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId,
hint);
}
/// @dev makes a trade between src and dest token and send dest tokens to msg sender
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapTokenToToken(ERC20 src,
uint srcAmount,
ERC20 dest,
uint minConversionRate)
public
returns(uint)
{
bytes memory hint;
return tradeWithHint(src,
srcAmount,
dest,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
/// @dev makes a trade from Ether to token. Sends token to msg sender
/// @param token Destination token
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint) {
bytes memory hint;
return tradeWithHint(ETH_TOKEN_ADDRESS,
msg.value,
token,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
/// @dev makes a trade from token to Ether, sends Ether to msg sender
/// @param token Src token
/// @param srcAmount amount of src tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @return amount of actual dest tokens
function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint) {
bytes memory hint;
return tradeWithHint(token,
srcAmount,
ETH_TOKEN_ADDRESS,
msg.sender,
MAX_QTY,
minConversionRate,
0,
hint);
}
struct UserBalance {
uint srcBalance;
uint destBalance;
}
event ExecuteTrade(address indexed trader, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @param hint will give hints for the trade.
/// @return amount of actual dest tokens
function tradeWithHint(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId,
bytes hint)
public
payable
returns(uint)
{
require(src == ETH_TOKEN_ADDRESS || msg.value == 0);
UserBalance memory userBalanceBefore;
userBalanceBefore.srcBalance = getBalance(src, msg.sender);
userBalanceBefore.destBalance = getBalance(dest, destAddress);
if (src == ETH_TOKEN_ADDRESS) {
userBalanceBefore.srcBalance += msg.value;
} else {
require(src.transferFrom(msg.sender, kyberNetworkContract, srcAmount));
}
uint reportedDestAmount = kyberNetworkContract.tradeWithHint.value(msg.value)(msg.sender,
src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId,
hint);
TradeOutcome memory tradeOutcome = calculateTradeOutcome(userBalanceBefore.srcBalance,
userBalanceBefore.destBalance,
src,
dest,
destAddress);
require(reportedDestAmount == tradeOutcome.userDeltaDestAmount);
require(tradeOutcome.userDeltaDestAmount <= maxDestAmount);
require(tradeOutcome.actualRate >= minConversionRate);
ExecuteTrade(msg.sender, src, dest, tradeOutcome.userDeltaSrcAmount, tradeOutcome.userDeltaDestAmount);
return tradeOutcome.userDeltaDestAmount;
}
event KyberNetworkSet(address newNetworkContract, address oldNetworkContract);
function setKyberNetworkContract(KyberNetworkInterface _kyberNetworkContract) public onlyAdmin {
require(_kyberNetworkContract != address(0));
KyberNetworkSet(_kyberNetworkContract, kyberNetworkContract);
kyberNetworkContract = _kyberNetworkContract;
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns(uint expectedRate, uint slippageRate)
{
return kyberNetworkContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return kyberNetworkContract.getUserCapInWei(user);
}
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint) {
return kyberNetworkContract.getUserCapInTokenWei(user, token);
}
function maxGasPrice() public view returns(uint) {
return kyberNetworkContract.maxGasPrice();
}
function enabled() public view returns(bool) {
return kyberNetworkContract.enabled();
}
function info(bytes32 field) public view returns(uint) {
return kyberNetworkContract.info(field);
}
struct TradeOutcome {
uint userDeltaSrcAmount;
uint userDeltaDestAmount;
uint actualRate;
}
function calculateTradeOutcome (uint srcBalanceBefore, uint destBalanceBefore, ERC20 src, ERC20 dest,
address destAddress)
internal returns(TradeOutcome outcome)
{
uint userSrcBalanceAfter;
uint userDestBalanceAfter;
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
//protect from underflow
require(userDestBalanceAfter > destBalanceBefore);
require(srcBalanceBefore > userSrcBalanceAfter);
outcome.userDeltaDestAmount = userDestBalanceAfter - destBalanceBefore;
outcome.userDeltaSrcAmount = srcBalanceBefore - userSrcBalanceAfter;
outcome.actualRate = calcRateFromQty(outcome.userDeltaSrcAmount,
outcome.userDeltaDestAmount,
getDecimalsSafe(src),
getDecimalsSafe(dest));
}
}
| 336,278 | 11,850 |
79ada9bbf056b67eaff90ce870e002b1c751376a06a1c1063e214e46428de219
| 23,974 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x0d93a7028c7cb9a1014917d52747c9bc210325cd_nonpublicVarAccessdByPublicFunc.sol
| 4,448 | 16,927 |
pragma solidity ^0.5.16;
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Unicorn {
/// @notice EIP-20 token name for this token
string internal constant name = "Unicorn";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "UNIC";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint internal totalSupply = 5_000_000e18; // 5 million Unic
/// @notice Address which may mint new tokens
address internal minter;
/// @notice The timestamp after which minting may occur
uint internal mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 internal constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 internal constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) internal 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)) internal checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) internal numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 internal 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 internal 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 internal 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) internal 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, "Unic::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, "Unic::setMinter: only the minter can change the minter address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit MinterChanged(minter, minter_); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
minter = minter_; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Unic::mint: only the minter can mint"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(block.timestamp >= mintingAllowedAfter, "Unic::mint: minting not allowed yet"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(dst != address(0), "Unic::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// mint the amount
uint96 amount = safe96(rawAmount, "Unic::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Unic::mint: exceeded mint cap"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Unic::mint: totalSupply exceeds 96 bits"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Unic::mint: transfer amount overflows"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Unic::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
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, "Unic::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Unic::permit: invalid signature");
require(signatory == owner, "Unic::permit: unauthorized");
require(now <= deadline, "Unic::permit: signature expired");
allowances[owner][spender] = amount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Unic::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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint96 amount = safe96(rawAmount, "Unic::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Unic::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Unic::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Unic::delegateBySig: invalid nonce"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
require(now <= expiry, "Unic::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Unic::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return checkpoints[account][nCheckpoints - 1].votes; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Unic::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Unic::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Unic::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Unic::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Unic::_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, "Unic::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Unic::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 277,994 | 11,851 |
f4d2bf161b0a9b93f6ce17db9b469753d46e4cde5b9b0437a80203752cf9bb22
| 22,928 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_37.sol
| 6,160 | 22,833 |
pragma solidity 0.4.25;
// ----------------------------------------------------------------------------
// 'August Coin' token contract
//
// Deployed to : 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD
// Symbol : AUC
// Name : AugustCoin
// Total supply: 100000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Ahiwe Onyebuchi Valentine.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
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])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
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.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug
redeemableEther_re_ent32[msg.sender] = 0;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
address lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = address(this).balance;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
function balanceOf(address tokenOwner) public view returns (uint balance);
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
function transfer(address to, uint tokens) public returns (bool success);
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
function approve(address spender, uint tokens) public returns (bool success);
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])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success);
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.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event Transfer(address indexed from, address indexed to, uint tokens);
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
mapping(address => uint) redeemableEther_re_ent4;
function deposit_re_ent4() public payable{
uint amount = msg.value;
redeemableEther_re_ent4[msg.sender]+=amount;
}
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.call.value(transferValue_re_ent4)(""); //bug //Reentrancy bug
redeemableEther_re_ent4[msg.sender] = 0;
}
address public owner;
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.call.value(transferValue_re_ent39)(""); //bug //Reentrancy bug
redeemableEther_re_ent39[msg.sender] = 0;
}
address public newOwner;
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
address lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract AugustCoin is ERC20Interface, Owned, SafeMath {
mapping(address => uint) balances_re_ent38;
function withdrawFunds_re_ent38 (uint256 _weiToWithdraw) public {
require(balances_re_ent38[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent38[msg.sender] -= _weiToWithdraw;
}
string public symbol;
address lastPlayer_re_ent37;
uint jackpot_re_ent37;
function buyTicket_re_ent37() public{
lastPlayer_re_ent37.call.value(jackpot_re_ent37)(""); //Reentrancy bug
revert();
lastPlayer_re_ent37 = msg.sender;
jackpot_re_ent37 = address(this).balance;
}
string public name;
mapping(address => uint) balances_re_ent36;
function withdraw_balances_re_ent36 () public {
msg.sender.call.value(balances_re_ent36[msg.sender ])(""); //Reentrancy bug
balances_re_ent36[msg.sender] = 0;
}
uint8 public decimals;
uint256 counter_re_ent35 =0;
function callme_re_ent35() public{
require(counter_re_ent35<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent35 += 1;
}
uint public _totalSupply;
mapping(address => uint) balances;
bool not_called_re_ent34 = true;
function bug_re_ent34() public{
require(not_called_re_ent34);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent34 = false;
}
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "AUC";
name = "AugustCoin";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD] = _totalSupply;
emit Transfer(address(0), 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD, _totalSupply);
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
address lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
// ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
// ------------------------------------------------------------------------
// 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] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
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)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
// ------------------------------------------------------------------------
// 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] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () external payable {
revert();
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
// ------------------------------------------------------------------------
// 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);
}
address lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
}
| 223,712 | 11,852 |
70b9c159fa724940fbd3dbe4a605f72e3b9fc314521e982fd863d1306fe63b96
| 16,486 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3a/3ae09319fad95d937e8ceee38d733563b2d7f356_LORD.sol
| 3,983 | 15,519 |
// SPDX-License-Identifier: Copyrighted
///@author @drotodev aka P.C.(I)
///@notice Anyway, use this at your own risk
pragma solidity ^0.8.4;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
///@dev This interface, extending IERC20, allows to control mint and burn of the rewards
interface IERC20RewardToken is IERC20 {
function mint_rewards(uint256 qty, address receiver) external;
function burn_tokens(uint256 qty, address burned) external;
}
contract LORD {
string public name = "LORD";
struct farm_slot {
bool active;
uint balance;
uint deposit_time;
uint locked_time;
address token;
}
struct farm_pool {
mapping(uint => uint) lock_multiplier;
mapping(address => uint) is_farming;
mapping(address => bool) has_farmed;
uint total_balance;
uint min_lock;
uint emission_rate;
address reward;
address owner;
bool mintable;
IERC20RewardToken reward_token;
IERC20 reward_token_fixed;
}
address public owner;
address[] public farms;
mapping(address => mapping(uint => farm_slot)) public farming_unit;
mapping(address => uint[]) farmer_pools;
mapping(address => address[]) owner_farms;
mapping(address => farm_pool) public token_pool;
mapping(address => uint) farm_id;
mapping(address => bool) public is_farmable;
mapping(address => uint) public last_tx;
mapping(address => mapping(uint => uint)) public lock_multiplier;
mapping(address => bool) public is_auth;
uint256 cooldown_time = 10 seconds;
// in constructor pass in the address for fang token and your custom bank token
// that will be used to pay interest
constructor() {
owner = msg.sender;
}
bool locked;
modifier farm_owner(address token) {
require((msg.sender == token_pool[token].owner) || (owner==msg.sender || is_auth[msg.sender]));
_;
}
modifier safe() {
require (!locked, "Guard");
locked = true;
_;
locked = false;
}
modifier cooldown() {
require(block.timestamp > last_tx[msg.sender] + cooldown_time, "Calm down");
_;
last_tx[msg.sender] = block.timestamp;
}
modifier authorized() {
require(owner==msg.sender || is_auth[msg.sender], "403");
_;
}
///@dev Returns the state of a specific pool owned by an user
///@param id The ID of the pool
///@param addy The address of the pool's owner
///@return A bool that indicates the state of the pool
function is_unlocked (uint id, address addy) public view returns(bool) {
return((block.timestamp > farming_unit[addy][id].deposit_time + farming_unit[addy][id].locked_time));
}
///@notice Events
event replenish(address token, uint qty, address from);
event farmed(address token, uint qty, address from, uint lock);
event withdraw(address token, uint qty, uint rewards, address from, uint id);
event rewarded(address token, uint rewards, address from, uint id, uint lock);
///@notice Public farming functions
///@dev Approves spending from this contract in behalf of sender
///@param token Which token need to be approved
function approveTokens(address token) public {
bool approved = IERC20(token).approve(address(this), 2**256 - 1);
require(approved, "Can't approve");
}
///@dev Deposit farmable tokens in the contract
///@param _amount The number of tokens to deposit (expecting decimals too)
///@param token The token to use as deposit
///@param locking Locking time (checked against the minimum of the pool) in seconds
function farmTokens(uint _amount, address token, uint locking) public {
require(is_farmable[token], "Farming not supported");
if(locking < token_pool[token].min_lock) {
locking = token_pool[token].min_lock;
}
require(IERC20(token).allowance(msg.sender, address(this)) >= _amount, "Allowance?");
// Trasnfer farmable tokens to contract for farming
bool transferred = IERC20(token).transferFrom(msg.sender, address(this), _amount);
require(transferred, "Not transferred");
// Update the farming balance in mappings
farm_id[msg.sender]++;
uint id = farm_id[msg.sender];
farming_unit[msg.sender][id].locked_time = locking;
farming_unit[msg.sender][id].balance = farming_unit[msg.sender][id].balance + _amount;
farming_unit[msg.sender][id].deposit_time = block.timestamp;
farming_unit[msg.sender][id].token = token;
token_pool[token].total_balance += _amount;
// Add user to farmrs array if they haven't farmd already
if(token_pool[token].has_farmed[msg.sender]) {
token_pool[token].has_farmed[msg.sender] = true;
}
// Update farming status to track
token_pool[token].is_farming[msg.sender]++;
farmer_pools[msg.sender].push(id);
// Emit an event
emit farmed(token, _amount, msg.sender, locking);
}
///@dev Unfarm tokens (if not locked)
///@param id The id of a pool owned by sender
function unfarmTokens(uint id) public safe cooldown {
require(is_unlocked(id, msg.sender), "Locking time not finished");
uint balance = _calculate_rewards(id, msg.sender);
// reqire the amount farmd needs to be greater then 0
require(balance > 0, "farming balance can not be 0");
address target_token = farming_unit[msg.sender][id].token;
bool mint = token_pool[target_token].mintable;
// transfer fang tokens out of this contract to the msg.sender
if(mint) {
IERC20RewardToken target_reward = token_pool[target_token].reward_token;
IERC20(target_token).transfer(msg.sender, farming_unit[msg.sender][id].balance);
target_reward.mint_rewards(balance, msg.sender);
} else {
IERC20 target_reward = token_pool[target_token].reward_token_fixed;
IERC20(target_token).transfer(msg.sender, farming_unit[msg.sender][id].balance);
require(target_reward.balanceOf(address(this)) >= balance, "Not enough supply");
target_reward.transfer(msg.sender, balance);
}
// reset farming balance map to 0
farming_unit[msg.sender][id].balance = 0;
farming_unit[msg.sender][id].active = false;
farming_unit[msg.sender][id].deposit_time = block.timestamp;
address token = farming_unit[msg.sender][id].token;
// update the farming status
token_pool[token].is_farming[msg.sender]--;
// Emit an event
emit withdraw(token, farming_unit[msg.sender][id].balance, balance, msg.sender, id);
}
///@dev Give rewards and clear the reward status
///@param id The id of a pool owned by sender
function issueInterestToken(uint id) public safe cooldown {
require(is_unlocked(id, msg.sender), "Locking time not finished");
address target_token = farming_unit[msg.sender][id].token;
uint balance = _calculate_rewards(id, msg.sender);
bool mint = token_pool[target_token].mintable;
if(mint) {
IERC20RewardToken target_reward = token_pool[target_token].reward_token;
target_reward.mint_rewards(balance, msg.sender);
} else {
IERC20 target_reward = token_pool[target_token].reward_token_fixed;
require(target_reward.balanceOf(address(this)) >= balance, "Not enough supply");
target_reward.transfer(msg.sender, balance);
}
// reset the time counter so it is not double paid
farming_unit[msg.sender][id].deposit_time = block.timestamp;
// Emit an event
emit rewarded(target_token, balance, msg.sender, id, farming_unit[msg.sender][id].locked_time);
}
///@notice Private functions
///@dev Helper to calculate rewards in a quick and lightweight way
///@param id The id of a pool owned by addy
///@param addy The address to calculate the rewards for
function _calculate_rewards(uint id, address addy) public view returns (uint) {
// get the users farming balance in fang
address local_token = farming_unit[addy][id].token;
uint percentage = (farming_unit[addy][id].balance*100)/token_pool[local_token].total_balance;
uint delta_time = block.timestamp - farming_unit[addy][id].deposit_time; // - initial deposit
uint time_bonus = (token_pool[farming_unit[addy][id].token].lock_multiplier[farming_unit[addy][id].locked_time]);
uint base_rate = token_pool[farming_unit[addy][id].token].emission_rate;
uint bonus = (base_rate * time_bonus)/100;
uint final_reward = base_rate + bonus;
uint total_rewards = (final_reward * delta_time);
uint balance = (total_rewards*percentage)/100;
return balance;
}
///@notice Control functions
///@param token The token to create the pool for
///@param reward The token that will be given as reward
///@param min_lock The minimum amount of time accepted as locking time
///@param emission_rate The emission rate per block of the reward token
///@param mintable Specify if the reward token is to mint or to take from the contract
///@param token_decimals The decimals of the reward token
function create_farmable(address token,
address reward,
uint min_lock,
uint emission_rate,
uint token_decimals,
bool mintable)
public payable safe cooldown {
require(!is_farmable[token], "Existing!");
require(IERC20(token).balanceOf(msg.sender)>0, "You don't own any token");
is_farmable[token] = true;
token_pool[token].reward = reward;
token_pool[token].min_lock = min_lock;
token_pool[token].emission_rate = emission_rate * (10**token_decimals);
token_pool[token].owner = msg.sender;
token_pool[token].mintable = mintable;
if(mintable) {
token_pool[token].reward_token = IERC20RewardToken(reward);
} else {
token_pool[token].reward_token_fixed = IERC20(reward);
}
owner_farms[msg.sender].push(token);
}
///@dev A farm owner can add tokens to a non mintable farm to replenish it
///@param amount How many tokens are given
///@param farmable The address of a farm
function add_to_farm_balance(uint amount, address farmable) public farm_owner(farmable) {
require(!token_pool[farmable].mintable, "You can't add balance to a mintable token");
require(IERC20(farmable).balanceOf(msg.sender) >= amount, "Not enough tokens");
require(IERC20(farmable).allowance(msg.sender, address(this)) >= amount, "Please approve spending");
bool sent = IERC20(farmable).transferFrom(msg.sender, address(this), amount);
require(sent, "Cannot transfer");
emit replenish(farmable, amount, msg.sender);
}
function get_single_pool(address tkn) public view returns(uint, uint, uint, address, address, bool) {
return(token_pool[tkn].total_balance,
token_pool[tkn].min_lock,
token_pool[tkn].emission_rate,
token_pool[tkn].reward,
token_pool[tkn].owner,
token_pool[tkn].mintable);
}
///@dev Get all the pools id for a farmer
///@param farmer The farmer address
///@return An array containing the IDs
function get_farmer_pools(address farmer) public view returns(uint[] memory) {
return(farmer_pools[farmer]);
}
///@dev Get all the farms id for an owner
///@param _owner The owner address
///@return An array containing the addresses
function get_owner_farms(address _owner) public view returns(address[] memory) {
return(owner_farms[_owner]);
}
///@dev Authorize or unauthorize an address to operate on this contract
///@param addy The target address
///@param booly Set true or false the authorization
function set_authorized(address addy, bool booly) public authorized {
is_auth[addy] = booly;
}
///@dev A farm owner can transfer the farm ownership
///@param token The farmable token to act on
///@param new_owner The new owner of the farm
function set_farm_owner(address token, address new_owner) public farm_owner(token) {
token_pool[token].owner = new_owner;
}
///@dev A farm owner can enable or disable a farm
///@param token The farm to target
///@param status Enable or disable with true or false
function set_farming_state(address token, bool status) public farm_owner(token) {
is_farmable[token] = status;
}
///@dev Get the status of a given farm
///@param token The farm to check
///@return Farm enabled or not enabled status
function get_farming_state(address token) public view returns (bool) {
return is_farmable[token];
}
///@dev A farm owner can set the multiplier applied based on locking time
///@param token The farm to target
///@param time The locking time to target
///@param multiplier The multiplier (in %) that will be added to the emission rate
function set_multiplier(address token, uint time, uint multiplier) public farm_owner(token) {
lock_multiplier[token][time] = multiplier;
}
///@dev Get the multiplier referred to a locking time for a farm
///@param token The farm to inspect
///@param time The locking time to inspect
///@return The multiplier applied to the emission rate for that farm
function get_multiplier(address token, uint time) public view returns(uint) {
return lock_multiplier[token][time];
}
///@notice time helpers
///@dev Get 1 day in seconds
///@return 1 day in seconds
function HELPER_get_1_day() public pure returns(uint) {
return(1 days);
}
///@dev Get 1 week in seconds
///@return 1 week in seconds
function HELPER_get_1_week() public pure returns(uint) {
return(7 days);
}
///@dev Get 30 days in seconds
///@return 30 days in seconds
function HELPER_get_1_month() public pure returns(uint) {
return(30 days);
}
///@dev Get 90 days in seconds
///@return 90 days in seconds
function HELPER_get_3_months() public pure returns(uint) {
return(90 days);
}
///@dev Get a number of days in seconds
///@return A number of days in seconds
function HELPER_get_x_days(uint x) public pure returns(uint) {
return((1 days*x));
}
///@dev Fallback function to receive ETH
receive() external payable {}
///@dev Fallback function for everything else
fallback() external payable {}
}
| 308,960 | 11,853 |
ac8724fb9e5f6e70ed9ffde23bdb066ca4181f66ffbe1a31430d4ec841ee391b
| 18,889 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYdMdbNahTm73mV2NBmAj1n7RxFEFCoGBN_FUTURETRXTEST.sol
| 4,609 | 17,467 |
//SourceUnit: futron.sol
pragma solidity >=0.4.23 <0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 FUTURETRXTEST {
using SafeMath for uint256;
struct USER {
bool joined;
uint id;
address payable upline;
uint personalCount;
uint poolAchiever;
bool is_trx_pool;
bool is_euro_trx_pool;
uint256 originalReferrer;
mapping(uint8 => MATRIX) Matrix;
mapping(uint8 => bool) activeLevel;
}
struct MATRIX {
address payable currentReferrer;
address payable[] referrals;
}
modifier onlyDeployer() {
require(msg.sender == deployer, "Only Deployer");
_;
}
uint maxDownLimit = 2;
uint public lastIDCount = 0;
uint public LAST_LEVEL = 9;
uint public poolTime = 24 hours;
uint public nextClosingTime = now + poolTime;
uint public deployerValidation = now + 24 hours;
address[] public trxPoolUsers;
address[] public euroTrxPoolUsers;
mapping(address => USER) public users;
mapping(uint256 => uint256) public LevelPrice;
uint256 public trxPoolAmount = 0;
uint256 public euroTrxPoolAmount = 0;
uint public DirectIncomeShare = 34;
uint public MatrixIncomeShare = 1;
uint public OverRideShare = 3;
uint public OtherOverRideShare = 3;
uint public CompanyShare = 9;
mapping(uint256 => uint256) public LevelIncome;
event Registration(address userAddress, uint256 accountId, uint256 refId);
event NewUserPlace(uint256 accountId, uint256 refId, uint place, uint level);
event Direct(uint256 accountId, uint256 from_id, uint8 level, uint256 amount);
event Level(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount);
event Matrix(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount);
event PoolEnterTrx(uint256 accountId, uint256 time);
event PoolEnterEuroTrx(uint256 accountId, uint256 time);
event PoolTrxIncome(uint256 accountId, uint256 amount);
event PoolEuroTrxIncome(uint256 accountId, uint256 amount);
event PoolAmountTrx(uint256 amount);
event PoolAmountEuroTrx(uint256 amount);
address public deployer;
address payable Company;
address payable public owner;
address payable public overRide;
address payable public otherOverRide;
mapping(uint256 => address payable) public userAddressByID;
constructor(address payable owneraddress, address payable _overRide, address payable _company, address payable _otherOverRide)
public
{
owner = owneraddress;
overRide = _overRide;
Company = _company;
otherOverRide = _otherOverRide;
deployer = msg.sender;
//LevelPrice[1] = 1250000000;
LevelPrice[1] = 12500000;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
LevelPrice[i] = LevelPrice[i-1] * 2;
}
LevelIncome[1] = 16;
LevelIncome[2] = 2;
LevelIncome[3] = 2;
LevelIncome[4] = 2;
LevelIncome[5] = 2;
LevelIncome[6] = 2;
LevelIncome[7] = 2;
LevelIncome[8] = 2;
LevelIncome[9] = 2;
USER memory user;
lastIDCount++;
user = USER({joined: true, id: lastIDCount, originalReferrer: 1, personalCount : 0, upline:address(0), poolAchiever : 0, is_trx_pool : false, is_euro_trx_pool :false});
users[owneraddress] = user;
userAddressByID[lastIDCount] = owneraddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[owneraddress].activeLevel[i] = true;
}
trxPoolUsers.push(owneraddress);
users[owneraddress].is_trx_pool = true;
}
function regUserDeployer(address payable userAddress, uint256 _referrerID) external onlyDeployer {
//this function is to rebind the users of old contract which is enabled only for first 24 hours only
require(deployerValidation > now, "This function is disabled!!!");
regUserInternal(userAddress, _referrerID);
}
function regUser(uint256 _referrerID) external payable {
require(msg.value == LevelPrice[1], "Incorrect Value");
regUserInternal(msg.sender, _referrerID);
}
function regUserInternal(address payable userAddress, uint256 _referrerID) internal {
uint256 originalReferrer = _referrerID;
uint8 _level = 1;
require(!users[userAddress].joined, "User exist");
require(_referrerID > 0 && _referrerID <= lastIDCount,"Incorrect referrer Id");
if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) {
_referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id;
}
users[userAddressByID[originalReferrer]].personalCount++;
USER memory UserInfo;
lastIDCount++;
UserInfo = USER({
joined: true,
id: lastIDCount,
upline : userAddressByID[originalReferrer],
originalReferrer: originalReferrer,
personalCount:0,
poolAchiever : 0,
is_trx_pool : false,
is_euro_trx_pool :false
});
users[userAddress] = UserInfo;
userAddressByID[lastIDCount] = userAddress;
emit Registration(userAddress, lastIDCount, originalReferrer);
users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID];
users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress);
emit NewUserPlace(lastIDCount, _referrerID, users[userAddressByID[_referrerID]].Matrix[1].referrals.length, _level);
users[userAddress].activeLevel[_level] = true;
if(msg.sender != deployer){
trxPoolAmount += LevelPrice[_level] / 20;
emit PoolAmountTrx(LevelPrice[_level] / 20);
euroTrxPoolAmount += LevelPrice[_level] / 20;
emit PoolAmountEuroTrx(LevelPrice[_level] / 20);
Company.transfer(LevelPrice[_level] * CompanyShare / 100);
overRide.transfer(LevelPrice[_level] * OverRideShare / 100);
otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100);
}
distributeDirectIncome(userAddress, _level);
levelIncomeDistribution(userAddress, _level);
matrixIncomeDistribution(userAddress, _level);
}
function buyLevelDeployer(address payable userAddress, uint8 _level) external onlyDeployer {
//this function is to rebind the users of old contract which is enabled only for first 24 hours only
require(deployerValidation > now, "This function is disabled!!!");
buyLevelInternal(userAddress, _level);
}
function buyLevel(uint8 _level) public payable {
require(msg.value == LevelPrice[_level], "Incorrect Value");
buyLevelInternal(msg.sender, _level);
}
function buyLevelInternal(address payable userAddress, uint8 _level) internal {
require(users[userAddress].joined, "User Not");
require(_level > 1 && _level <= LAST_LEVEL, "Incorrect Level");
require(!users[userAddress].activeLevel[_level], "Already active");
require(users[userAddress].activeLevel[_level - 1], "Previous Level");
uint256 _referrerID = findFreeActiveReferrer(userAddress, _level);
if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) {
_referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id;
}
users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID];
users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress);
emit NewUserPlace(users[userAddress].id, _referrerID, users[userAddressByID[_referrerID]].Matrix[_level].referrals.length, _level);
users[userAddress].activeLevel[_level] = true;
if(msg.sender != deployer) {
trxPoolAmount += LevelPrice[_level] / 20;
emit PoolAmountTrx(LevelPrice[_level] / 20);
euroTrxPoolAmount += LevelPrice[_level] / 20;
emit PoolAmountEuroTrx(LevelPrice[_level] / 20);
Company.transfer(LevelPrice[_level] * CompanyShare / 100);
overRide.transfer(LevelPrice[_level] * OverRideShare / 100);
otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100);
}
distributeDirectIncome(userAddress, _level);
levelIncomeDistribution(userAddress, _level);
matrixIncomeDistribution(userAddress, _level);
if(_level == LAST_LEVEL) {
emit PoolEnterTrx(users[userAddress].id, now);
users[userAddress].is_trx_pool = true;
trxPoolUsers.push(userAddress);
users[users[userAddress].upline].poolAchiever++;
if(users[users[userAddress].upline].is_euro_trx_pool == false) {
if(users[users[userAddress].upline].poolAchiever >= 2 && users[users[userAddress].upline].is_trx_pool == true){
emit PoolEnterEuroTrx(users[userAddress].originalReferrer, now);
users[users[userAddress].upline].is_euro_trx_pool = true;
euroTrxPoolUsers.push(users[userAddress].upline);
}
}
if(users[userAddress].is_euro_trx_pool == false) {
if(users[userAddress].poolAchiever >= 2) {
emit PoolEnterEuroTrx(users[userAddress].originalReferrer, now);
users[userAddress].is_euro_trx_pool = true;
euroTrxPoolUsers.push(userAddress);
}
}
}
}
function distributeDirectIncome(address _user, uint8 _level) internal {
uint256 income = LevelPrice[_level] * DirectIncomeShare / 100;
if(users[_user].upline != address(0)) {
if(users[users[_user].upline].activeLevel[_level] == true) {
emit Direct(users[_user].originalReferrer,users[_user].id, _level, income);
if(msg.sender != deployer){
(users[_user].upline).transfer(income);
}
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
euroTrxPoolAmount += income / 2;
emit PoolAmountEuroTrx(income / 2);
}
}
}
}
function levelIncomeDistribution(address _user, uint8 _level) internal {
address payable _upline = users[_user].upline;
for(uint8 i = 1; i <= 9; i++) {
uint256 income = LevelPrice[_level] * LevelIncome[i] / 100;
if(_upline != address(0)) {
emit Level(users[_upline].id, users[_user].id, _level, i, income);
if(msg.sender != deployer){
if(!address(uint160(_upline)).send(income)) {
address(uint160(_upline)).transfer(income);
}
}
_upline = users[_upline].upline;
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
euroTrxPoolAmount += income / 2;
emit PoolAmountEuroTrx(income / 2);
}
}
}
}
function matrixIncomeDistribution(address _user, uint8 _level) internal {
address payable _upline = users[_user].Matrix[_level].currentReferrer;
for(uint8 i = 1; i <= 9; i++) {
uint256 income = LevelPrice[_level] * MatrixIncomeShare / 100;
if(_upline != address(0)) {
if(users[_upline].activeLevel[i] == true) {
emit Matrix(users[_upline].id, users[_user].id, _level, i, income);
if(msg.sender != deployer){
if(!address(uint160(_upline)).send(income)) {
address(uint160(_upline)).transfer(income);
}
}
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
euroTrxPoolAmount += income / 2;
emit PoolAmountEuroTrx(income / 2);
}
}
_upline = users[_upline].Matrix[_level].currentReferrer;
}
else {
if(msg.sender != deployer){
trxPoolAmount += income / 2;
emit PoolAmountTrx(income / 2);
euroTrxPoolAmount += income / 2;
emit PoolAmountEuroTrx(income / 2);
}
}
}
}
function findFreeActiveReferrer(address userAddress, uint8 level) internal view returns(uint256) {
while (true) {
if (users[users[userAddress].upline].activeLevel[level] == true) {
return users[users[userAddress].upline].id;
}
userAddress = users[userAddress].upline;
}
}
function poolClosing(uint pool) public onlyDeployer {
require(now > nextClosingTime, "Closing Time not came yet!!!");
if(now > nextClosingTime){
if(pool == 1) {
if(trxPoolAmount > 0) {
uint256 perUserAmount = trxPoolAmount / trxPoolUsers.length;
for(uint i = 0; i < trxPoolUsers.length; i++) {
address userAddress = trxPoolUsers[i];
emit PoolTrxIncome(users[userAddress].id, perUserAmount);
if(!address(uint160(userAddress)).send(perUserAmount)){
return address(uint160(userAddress)).transfer(perUserAmount);
}
}
trxPoolAmount = 0;
}
}
if(pool == 2) {
if(euroTrxPoolAmount > 0) {
uint256 perUserAmount = euroTrxPoolAmount / euroTrxPoolUsers.length;
for(uint i = 0; i < euroTrxPoolUsers.length; i++) {
address userAddress = euroTrxPoolUsers[i];
emit PoolEuroTrxIncome(users[userAddress].id, perUserAmount);
if(!address(uint160(userAddress)).send(perUserAmount)){
return address(uint160(userAddress)).transfer(perUserAmount);
}
}
euroTrxPoolAmount = 0;
}
nextClosingTime = now.add(poolTime);
}
}
}
function findFreeReferrer(address _user, uint8 _level) internal view returns(address) {
if(users[_user].Matrix[_level].referrals.length < maxDownLimit){
return _user;
}
address[] memory referrals = new address[](2046);
referrals[0] = users[_user].Matrix[_level].referrals[0];
referrals[1] = users[_user].Matrix[_level].referrals[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i =0; i<2046;i++){
if(users[referrals[i]].Matrix[_level].referrals.length == maxDownLimit){
if(i<1022){
referrals[(i+1)*2] = users[referrals[i]].Matrix[_level].referrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].Matrix[_level].referrals[1];
}
}else{
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function getMatrix(address userAddress, uint8 level)
public
view
returns (address payable,
address payable[] memory)
{
return (users[userAddress].Matrix[level].currentReferrer,
users[userAddress].Matrix[level].referrals);
}
function getPendingTimeForNextClosing() public view returns(uint) {
uint remainingTimeForPayout = 0;
if(nextClosingTime >= now) {
remainingTimeForPayout = nextClosingTime.sub(now);
}
return remainingTimeForPayout;
}
}
| 302,643 | 11,854 |
aba4664d93f8a1f03cdcb8c67c2e812438f62860874585406711126d937e61ef
| 14,703 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWbqVngUwVPLQrTJBT64ETtBbroqHqYL9Z_YBCDMXSFarm.sol
| 3,148 | 11,675 |
//SourceUnit: YBCDMXSFarm.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library 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;
}
}
library SafeTRC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 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));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 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(ITRC20 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(ITRC20 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.
// require(address(token).isContract());
require(address(token) != tx.origin);
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {// Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract YBCDMXSFarm is Context, Ownable {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
struct User {
address referral;
uint256 amount;
uint256 balance;
uint256 stake_reward;
uint256 referral_reward;
Order[] orders;
bool exist;
}
struct Order {
uint256 amount;
uint256 time;
}
mapping(address => User) public users;
ITRC20 public token = ITRC20(0x41849C6188A39DC6298219AC10D74BB20E97AF0317);
ITRC20 public lpToken = ITRC20(0x4177FF3B85B14C6ACECABE95E591299E2098065816);
uint256 public rewardDuration = 30 days;
uint256 public constant PERCENT = 100;
uint256 public REFERRAL_RATE = 30;
uint256 public totalStakeAmount = 0;
event Referral(address indexed addr, address indexed upline);
event Stake(address indexed addr, uint256 amount);
event CancelStake(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReferralReward(address indexed addr, address indexed referral, uint256 amount);
constructor() public {
}
function _setReferral(address _addr, address _referral) private {
if (_referral != address(0) && users[_addr].referral == address(0) && _referral != _addr) {
users[_addr].referral = _referral;
users[_addr].exist = true;
emit Referral(_addr, _referral);
}
}
function _referralReward(address _addr, uint256 _amount) private {
if (users[_addr].referral != address(0)) {
uint256 reward = _amount.mul(REFERRAL_RATE).div(PERCENT);
if (reward > 0) {
if (users[users[_addr].referral].exist == true && users[users[_addr].referral].amount > 0) {
users[users[_addr].referral].referral_reward = users[users[_addr].referral].referral_reward.add(reward);
token.safeTransfer(users[_addr].referral, reward);
emit ReferralReward(_addr, users[_addr].referral, reward);
}
}
}
}
function _stake(address _addr, uint256 _amount) private {
require(users[_addr].referral != address(0), 'need referral');
lpToken.safeTransferFrom(_addr, address(this), _amount);
users[_addr].amount = users[_addr].amount.add(_amount);
totalStakeAmount = totalStakeAmount.add(_amount);
users[_addr].orders.push(Order(_amount,
block.timestamp));
emit Stake(msg.sender, _amount);
}
function stake(uint256 _amount, address _referral) public {
_setReferral(msg.sender, _referral);
_stake(msg.sender, _amount);
}
function cancelStake() public {
uint256 stake_amount = users[msg.sender].amount;
require(stake_amount > 0, 'no stake');
uint256 reward = getUnSettlementReward(msg.sender);
users[msg.sender].balance = users[msg.sender].balance.add(reward);
users[msg.sender].amount = 0;
delete users[msg.sender].orders;
if (totalStakeAmount > stake_amount) {
totalStakeAmount = totalStakeAmount.sub(stake_amount);
} else {
totalStakeAmount = 0;
}
lpToken.safeTransfer(msg.sender, stake_amount);
emit CancelStake(msg.sender, stake_amount);
}
function withdraw() public {
uint256 reward = getUnSettlementReward(msg.sender);
_refreshOrders(msg.sender);
reward = reward.add(users[msg.sender].balance);
require(reward > 0 ,'no reward');
users[msg.sender].balance = 0;
token.safeTransfer(msg.sender, reward);
emit Withdraw(msg.sender, reward);
_referralReward(msg.sender, reward);
}
function _refreshOrders(address _addr) internal{
Order[] storage orders = users[_addr].orders;
for(uint i=0;i<orders.length;i++) {
if (orders[i].time.add(rewardDuration) <= block.timestamp) {
uint256 period = (block.timestamp.sub(orders[i].time)).div(rewardDuration);
orders[i].time = orders[i].time.add(period.mul(rewardDuration));
}
}
}
function getUserReward() public view returns(uint256) {
uint256 reward = getUnSettlementReward(msg.sender);
reward = reward.add(users[msg.sender].balance);
return reward;
}
function getUnSettlementReward(address _addr) public view returns(uint256){
Order[] storage orders = users[_addr].orders;
uint256 poolAmount = getGlobalPoolAmount();
uint256 reward = 0;
if (poolAmount > 0) {
for(uint i=0;i<orders.length;i++) {
if (orders[i].time.add(rewardDuration) <= block.timestamp) {
uint256 period = (block.timestamp.sub(orders[i].time)).div(rewardDuration);
if (period > 0) {
reward = reward.add(orders[i].amount.mul(getPoolReward()).mul(period).div(poolAmount));
}
}
}
}
return reward;
}
function getGlobalPoolAmount() public view returns(uint256) {
return lpToken.totalSupply();
}
function getPoolReward() public view returns(uint256) {
return token.balanceOf(address(this));
}
function getUserStake(address _addr) public view returns(uint256, uint256) {
return (users[_addr].amount, totalStakeAmount);
}
}
| 292,661 | 11,855 |
61628bf3857d95494b88f308bc645ef213759998319c4a12b878b22160af5214
| 30,559 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ45kNZLFxofPE2jBpdwzCEwRm2NwKwvLs_Farm.sol
| 5,174 | 19,656 |
//SourceUnit: farmv-0.3.sol
pragma solidity ^0.5.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function burn(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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {codehash := extcodehash(account)}
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
//require(Address.isContract(address(token)), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward) external ;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public inCoin;
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);
_balances[msg.sender] = _balances[msg.sender].add(amount);
inCoin.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
inCoin.safeTransfer(msg.sender, amount);
}
}
contract Farm is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public outCoin;
uint256 public constant DURATION = 10 days;
uint256 public startTime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 constant l1Reward = 10;
uint256 constant l2Reward = 5;
address public genesisMiner ;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
struct ReferralAddr {
address addr;
bool valid;
}
//IterableMapping.itmap referralRelationships;
mapping(address => ReferralAddr[]) referralRelationships;
mapping(address => address) alreadyReferraled;
mapping(address => uint256) public frozenReferralRewards;
mapping(address => uint256) public referralRewardsWithdraw;
mapping(address => uint256) public lastGetReward;
PoolInfo public poolInfo;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event WithdrawReferralRewards(address indexed user, uint256 amount);
struct PoolInfo {
uint256 startTime;
uint256 finishTime;
uint256 totalReward;
uint256 rewardRate;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(IERC20 _inCoin, IERC20 _outCoin, uint256 _startTime, address _miner) public {
inCoin = _inCoin;
outCoin = _outCoin;
startTime = _startTime;
genesisMiner = _miner;
}
///
function _updateReferralRelationship(address user, address referrer) internal {
if (referrer == user) {// referrer cannot be user himself/herself
return;
}
require(balanceOf(referrer) > 0 || referrer == genesisMiner, "user Doesn't deposit");
if (referrer == address(0)) {// Cannot be address 0
return;
}
if (alreadyReferraled[user] != address(0)) {//referrer has been set
return;
}
alreadyReferraled[user] = referrer;
referralRelationships[referrer].push(ReferralAddr(user, true));
//IterableMapping.insert(referralRelationships, user, referrer);
}
///
function getReferrer(address account) public view returns (address) {
return alreadyReferraled[account];
}
//
function getReferralRewards(address account) public view returns (uint256) {
uint256 availableReferralRewards = getLevelReferralRewards(account, l1Reward, l2Reward, true);
availableReferralRewards = availableReferralRewards.add(frozenReferralRewards[account]);
availableReferralRewards = availableReferralRewards.sub(referralRewardsWithdraw[account]);
return availableReferralRewards;
}
function getLevelReferralRewards(address account, uint256 rate1, uint256 rate2, bool isContinue) internal view returns (uint256) {
uint256 availableReferralRewards = 0;
uint256 rate = rate1;
if(!isContinue) {
rate = rate2;
}
for(uint i = 0; i < referralRelationships[account].length; i ++) {
//
if(referralRelationships[account][i].valid) {
address user = referralRelationships[account][i].addr;
uint256 reward = earned(user);
if(reward > 0) {
availableReferralRewards = availableReferralRewards.add(reward.mul(rate).div(100));
}
//
if(isContinue) {
reward = getLevelReferralRewards(user, rate1, rate2, false);
if(reward > 0) {
availableReferralRewards = availableReferralRewards.add(reward);
}
}
}
}
return availableReferralRewards;
}
function withdrawReferralRewards(uint256 amount) public checkStart {
address user = msg.sender;
uint256 availableReferralRewards = getReferralRewards(user);
require(amount <= availableReferralRewards, "not sufficient referral rewards");
referralRewardsWithdraw[user] = referralRewardsWithdraw[user].add(amount);
safeOSKTransfer(user, amount);
emit WithdrawReferralRewards(user, amount);
}
///
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
//
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
///
function deposit(uint256 amount, address referrer) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
require(block.timestamp < periodFinish, "mint finish");
super.stake(amount);
_updateReferralRelationship(msg.sender, referrer);
emit Staked(msg.sender, amount);
}
///
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
///
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
safeOSKTransfer(msg.sender, reward);
if(alreadyReferraled[msg.sender] != address(0)) {
address referrer = alreadyReferraled[msg.sender];
uint256 referrerFee = reward.mul(l1Reward).div(100);
frozenReferralRewards[referrer] = frozenReferralRewards[referrer].add(referrerFee);
//
if(alreadyReferraled[referrer] != address(0)) {
address referrer2 = alreadyReferraled[referrer];
uint256 referrerFee2 = reward.mul(l2Reward).div(100);
frozenReferralRewards[referrer2] = frozenReferralRewards[referrer2].add(referrerFee2);
}
}
emit RewardPaid(msg.sender, reward);
}
}
function safeOSKTransfer(address _to, uint256 _amount) internal {
uint256 oskBalance = outCoin.balanceOf(address(this));
if (_amount > oskBalance) {
outCoin.safeTransfer(_to, oskBalance);
} else {
outCoin.safeTransfer(_to, _amount);
}
}
modifier checkStart(){
require(block.timestamp > startTime, "not start");
_;
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
lastUpdateTime = startTime;
periodFinish = startTime.add(DURATION);
poolInfo.startTime = startTime;
poolInfo.finishTime = periodFinish;
poolInfo.totalReward = reward.add(reward.mul(l1Reward).div(100)).add(reward.mul(l2Reward).div(100));
poolInfo.rewardRate = rewardRate;
}
emit RewardAdded(reward);
}
///
function getRecommendLp(address who) internal view returns(uint256) {
uint256 l1RecommendAmount = 0;
for(uint256 i = 0; i < referralRelationships[who].length; i ++) {
address sonaddr = referralRelationships[who][i].addr;
l1RecommendAmount = l1RecommendAmount.add(balanceOf(sonaddr));
}
return l1RecommendAmount;
}
function getRecommend(address who, uint8 page) external view returns(address[10] memory , uint256[10] memory, uint256[10] memory, uint256, uint256) {
uint256 total = referralRelationships[who].length;
uint256[10] memory l2Count ;
uint256[10] memory groupAmount ;
address[10] memory userlist;
uint256 ibegin ;
uint256 iend ;
uint256 lAmount = 0;
address who1 = who;
if(total / 10 <= page) {
ibegin = (total / 10) * 10;
iend = total;
} else {
ibegin = page * 10;
iend = (page + 1) * 10;
}
for(uint256 i = ibegin; i < iend; i ++) {
address son = referralRelationships[who1][i].addr;
userlist[i-ibegin] = son;
l2Count[i-ibegin] = referralRelationships[son].length;
lAmount = getRecommendLp(son);
groupAmount[i-ibegin] = lAmount.add(balanceOf(son));
}
return (userlist, l2Count, groupAmount, iend - ibegin, total);
}
function afterMint() external onlyRewardDistribution {
require(block.timestamp >= periodFinish, "the lp mined not over");
uint256 amount = outCoin.balanceOf(address(this));
if(amount > 0) {
outCoin.safeTransfer(msg.sender, amount);
}
}
}
| 291,173 | 11,856 |
ca2d48f458da42239e45ad2bde541d9e42ef3649843783633b276e3ab4b6616f
| 17,647 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x18bead88a1ae0838a298f9404ea398b7346dfb07.sol
| 3,307 | 11,698 |
pragma solidity ^0.5.1;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(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(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
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 Crowdsale is ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// start ICO
uint256 public _startStage1;
uint256 public _startStage2;
// Address where funds are collected
address payable private _wallet;
uint256 public _maxPay;
uint256 public _minPay;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
// token - EUR
uint256 private _rate; // 6 decimals
// Amount of wei raised
uint256 private _weiRaised;
//whitelist
mapping (address => uint32) public whitelist;
//for startStage2
uint256 _totalNumberPayments = 0;
uint256 _numberPaidPayments = 0;
mapping(uint256 => address) _paymentAddress;
mapping(uint256 => uint256) _paymentDay;
mapping(uint256 => uint256) _paymentValue;
mapping(uint256 => uint256) _totalAmountDay;
mapping(uint256 => uint8) _paymentFlag;
uint256 public _amountTokensPerDay;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor () public {
_startStage1 = 1553083200;
_startStage2 = 1554379201;
_rate = 285;
_wallet = 0x68A924EA85c96e74A05cf12465cB53702a560811;
_token = IERC20(0xC0D766017141dd4866738C1e704Be6feDc97B904);
_amountTokensPerDay = 2000000000000000000000000;
_maxPay = 1 * 100 ether;
_minPay = 1 * 200000000000000000;
require(_rate > 0);
require(_wallet != address(0));
require(address(_token) != address(0));
require(_startStage2 > _startStage1 + 15 * 1 days);
}
// 1 - allow, 0 - denied
function setWhiteList(address _address, uint32 _flag) public onlyOwner {
whitelist[_address] = _flag;
}
// 1 - allow
function addAddressToWhiteList(address[] memory _addr) public onlyOwner {
for(uint256 i = 0; i < _addr.length; i++) {
whitelist[_addr[i]] = 1;
}
}
// 0 - denied
function subAddressToWhiteList(address[] memory _addr) public onlyOwner {
for(uint256 i = 0; i < _addr.length; i++) {
whitelist[_addr[i]] = 0;
}
}
function setRate(uint256 rate) public onlyOwner {
_rate = rate;
}
function setMaxPay(uint256 maxPay) public onlyOwner {
_maxPay = maxPay;
}
function setMinPay(uint256 minPay) public onlyOwner {
_minPay = minPay;
}
function _returnTokens(address wallet, uint256 value) public onlyOwner {
_token.transfer(wallet, value);
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount;
uint256 tokens;
weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
if (now >= _startStage1 && now < _startStage2){
require(whitelist[msg.sender] == 1);
// calculate token amount to be created
tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_forwardFunds();
}
if (now >= _startStage2 && now < _startStage2 + 272 * 1 days){
_totalNumberPayments = _totalNumberPayments + 1;
_paymentAddress[_totalNumberPayments] = msg.sender;
_paymentValue[_totalNumberPayments] = msg.value;
_paymentDay[_totalNumberPayments] = _getDayNumber();
_totalAmountDay[_getDayNumber()] = _totalAmountDay[_getDayNumber()] + msg.value;
_forwardFunds();
}
}
function makePayment(uint256 numberPayments) public onlyOwner{
address addressParticipant;
uint256 paymentValue;
uint256 dayNumber;
uint256 totalPaymentValue;
uint256 tokensAmount;
if (numberPayments > _totalNumberPayments.sub(_numberPaidPayments)){
numberPayments = _totalNumberPayments.sub(_numberPaidPayments);
}
uint256 startNumber = _numberPaidPayments.add(1);
uint256 endNumber = _numberPaidPayments.add(numberPayments);
for (uint256 i = startNumber; i <= endNumber; ++i) {
if (_paymentFlag[i] != 1){
dayNumber = _paymentDay[i];
if (_getDayNumber() > dayNumber){
addressParticipant = _paymentAddress[i];
paymentValue = _paymentValue[i];
totalPaymentValue = _totalAmountDay[dayNumber];
tokensAmount = _amountTokensPerDay.mul(paymentValue).div(totalPaymentValue);
_token.safeTransfer(addressParticipant, tokensAmount);
_paymentFlag[i] = 1;
_numberPaidPayments = _numberPaidPayments + 1;
}
}
}
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
require(weiAmount >= _minPay);
require(weiAmount <= _maxPay);
require(now >= _startStage1 && now <= _startStage2 + 272 * 1 days);
}
function _getAmountUnpaidPayments() public view returns (uint256){
return _totalNumberPayments.sub(_numberPaidPayments);
}
function _getDayNumber() internal view returns (uint256){
return ((now.add(1 days)).sub(_startStage2)).div(1 days);
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
// tokensAmount = weiAmount.mul(_rateETHEUR).mul(10000).div(_rate);
// return weiAmount.mul(_rate);
uint256 bonus;
if (now >= _startStage1 && now < _startStage1 + 5 * 1 days){
bonus = 20;
}
if (now >= _startStage1 + 5 * 1 days && now < _startStage1 + 10 * 1 days){
bonus = 10;
}
if (now >= _startStage1 + 10 * 1 days && now < _startStage1 + 15 * 1 days){
bonus = 0;
}
return weiAmount.mul(1000000).div(_rate) + (weiAmount.mul(1000000).mul(bonus).div(_rate)).div(100);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
| 216,463 | 11,857 |
264810eb571c3c53e8056901d0ac0bfdcec0b827ae94c4b25382229770987688
| 16,903 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/87/87aeaa0a46545286eCfEcCCB2a48AfEca61d7E56_Helper.sol
| 3,745 | 15,911 |
// 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 Helper {
function getBalance() external view returns (uint) {
return address(this).balance;
}
function kill(Kill _kill) external {
_kill.kill();
}
}
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 Kill 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 "Kill";
}
function symbol() external pure override returns (string memory) {
return "KILL";
}
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 kill() external {
selfdestruct(payable(msg.sender));
}
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);
}
}
}
}
| 308,728 | 11,858 |
da6a3fa20eb095fea75a9278b350d3ca6bd3938145c8e4c807ab13d31afe54a7
| 15,784 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3f05c0d81fae7f9f209fae5402d25a9a42d03fa7.sol
| 3,948 | 15,593 |
pragma solidity 0.5.13;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Blacklistable is Ownable {
address public blacklister;
mapping(address => bool) internal blacklisted;
event Blacklisted(address indexed _account);
event UnBlacklisted(address indexed _account);
event BlacklisterChanged(address indexed newBlacklister);
modifier onlyBlacklister() {
require(msg.sender == blacklister);
_;
}
modifier notBlacklisted(address _account) {
require(blacklisted[_account] == false);
_;
}
function isBlacklisted(address _account) public view returns (bool) {
return blacklisted[_account];
}
function blacklist(address _account) public onlyBlacklister {
blacklisted[_account] = true;
emit Blacklisted(_account);
}
function unBlacklist(address _account) public onlyBlacklister {
blacklisted[_account] = false;
emit UnBlacklisted(_account);
}
function updateBlacklister(address _newBlacklister) public onlyOwner {
require(_newBlacklister != address(0));
blacklister = _newBlacklister;
emit BlacklisterChanged(blacklister);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(_msgSender());
}
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is Context, PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
contract XUSD is Ownable, ERC20, Pausable, Blacklistable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
string public currency;
address public masterMinter;
address public pauser;
bool internal initialized;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_ = 0;
mapping(address => bool) internal minters;
mapping(address => uint256) internal minterAllowed;
event Mint(address indexed minter, address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 amount);
event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);
event MinterRemoved(address indexed oldMinter);
event MasterMinterChanged(address indexed newMasterMinter);
function initialize(string memory _name,
string memory _symbol,
string memory _currency,
uint8 _decimals,
address _masterMinter,
address _pauser,
address _blacklister,
address _owner) public {
require(!initialized);
require(_masterMinter != address(0));
require(_pauser != address(0));
require(_blacklister != address(0));
require(_owner != address(0));
name = _name;
symbol = _symbol;
currency = _currency;
decimals = _decimals;
masterMinter = _masterMinter;
pauser = _pauser;
blacklister = _blacklister;
initialized = true;
}
modifier onlyMinters() {
require(minters[msg.sender] == true);
_;
}
function mint(address _to, uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) {
require(_to != address(0));
require(_amount > 0);
uint256 mintingAllowedAmount = minterAllowed[msg.sender];
require(_amount <= mintingAllowedAmount);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);
emit Mint(msg.sender, _to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
modifier onlyMasterMinter() {
require(msg.sender == masterMinter);
_;
}
function minterAllowance(address minter) public view returns (uint256) {
return minterAllowed[minter];
}
function isMinter(address account) public view returns (bool) {
return minters[account];
}
function allowance(address owner, address spender) public view returns (uint256) {
return allowed[owner][spender];
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address account) public view returns (uint256) {
return balances[account];
}
function approve(address _spender, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_spender) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused notBlacklisted(_to) notBlacklisted(msg.sender) notBlacklisted(_from) 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 transfer(address _to, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function configureMinter(address minter, uint256 minterAllowedAmount) whenNotPaused onlyMasterMinter public returns (bool) {
minters[minter] = true;
minterAllowed[minter] = minterAllowedAmount;
emit MinterConfigured(minter, minterAllowedAmount);
return true;
}
function removeMinter(address minter) onlyMasterMinter public returns (bool) {
minters[minter] = false;
minterAllowed[minter] = 0;
emit MinterRemoved(minter);
return true;
}
function burn(uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) public {
uint256 balance = balances[msg.sender];
require(_amount > 0);
require(balance >= _amount);
totalSupply_ = totalSupply_.sub(_amount);
balances[msg.sender] = balance.sub(_amount);
emit Burn(msg.sender, _amount);
emit Transfer(msg.sender, address(0), _amount);
}
function updateMasterMinter(address _newMasterMinter) onlyOwner public {
require(_newMasterMinter != address(0));
masterMinter = _newMasterMinter;
emit MasterMinterChanged(masterMinter);
}
}
| 163,105 | 11,859 |
9a2aa04f7082cbfb7b90f5df28c7e0cf5afaf858c8592dfe9360a6fb37e57e7a
| 21,115 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKYjshnLGzqMXwvAq4WrGVnQ4gE9GYEsV8_Trodl.sol
| 3,113 | 11,770 |
//SourceUnit: Trodl.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Trodl is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10 * 10**4 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 4;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10 * 10**4 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
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 totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _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 (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 300,197 | 11,860 |
ebc86acdda926be6d43ea8fd8d5cffbaa8ce9f781b76bb4d6d7d07aee0711616
| 16,074 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/71/7171e151319496da99ee52cd3fff198d147550fb_BusdToken.sol
| 2,933 | 12,053 |
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;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
emit Transfer(msg.sender, owner, fee);
}
emit Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint256 _allowance ;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public {
// _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
// uint fee = (_value.mul(basisPointsRate)).div(10000);
// if (fee > maximumFee) {
// fee = maximumFee;
// }
// if (_allowance < MAX_UINT) {
// allowed[_from][msg.sender] = _allowance.sub(_value);
// }
// uint sendAmount = _value.sub(fee);
// balances[_from] = balances[_from].sub(_value);
// balances[_to] = balances[_to].add(sendAmount);
// if (fee > 0) {
// balances[owner] = balances[owner].add(fee);
// emit Transfer(_from, owner, fee);
// }
// emit Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
emit AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
emit RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract BusdToken is StandardToken {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
function delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function getImplementationAddress() public view returns (address) {
// Returns the address of the implementation contract
return 0x1D1b8DA1826Cc7624b91C4c616ECD3FD1Ca04b71;
}
function fallback() external {
delegate(getImplementationAddress());
}
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
constructor(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public {
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public {
}
function underlying() public returns (address) {
return address(this);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
emit Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
emit Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
emit Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
emit Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 316,802 | 11,861 |
fc53df857e7f67f5fbae4a9f49d1acc7eb82027518f53af9302cf33c08a2edd0
| 25,534 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/7402_10697_0xe1030b48b2033314979143766d7dc1f40ef8ce11.sol
| 4,562 | 16,765 |
// 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 ThePeoplesCoin 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 = 1000000000 * 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'The Peoples Coin';
string private _symbol = 'PEEPS';
uint8 private _decimals = 18;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function 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(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);
}
}
| 232,001 | 11,862 |
1a429ef4051241765d78438e3468f800c74aef18e68b4105d4c29f0cb5e67d37
| 28,792 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e9/E974A88385935CB8846482F3Ab01b6c0f70fa5f3_MPXBonderWFTM.sol
| 4,045 | 15,391 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface MORPHIERC20 {
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);
function mint(address _to, uint256 _amount) external ;
}
library MORPHSafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(MORPHIERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(MORPHIERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(MORPHIERC20 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(MORPHIERC20 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(MORPHIERC20 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(MORPHIERC20 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');
}
}
}
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);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view 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 () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface VestingEscrowFactory {
function deploy_vesting_contract(address token,
address recipient,
uint256 amount,
uint256 vesting_duration,
uint256 vesting_start,
uint256 cliff_length) external returns (address);
}
pragma experimental ABIEncoderV2;
contract MPXBonderWFTM is Context, Ownable, ReentrancyGuard {
using MORPHSafeERC20 for MORPHIERC20;
using SafeMath for uint256;
using Address for address;
MORPHIERC20 public bondingToken;
MORPHIERC20 public mpx;
VestingEscrowFactory public vestingFactory;
address public treasuryAddress;
address public gov;
mapping(address => uint256) public contributions;
uint256 public minCap;
uint256 public maxCap;
uint256 public ratio;
uint256 public bondStartTime;
bool public bondEnabled;
bool public factoryApproved = false;
uint256 constant public vestingPeriod = 365 days;
uint256 constant public cliffLength = 60 days;
uint256 constant MAX_INT = type(uint256).max;
event Bonded(address user, uint256 amount, address userVestingContract);
event SetBondState (bool bondEnabled);
event SetGov (address gov);
event SetTreasury(address treasury);
event FactoryApproved(bool factoryApproved);
event SetRate(uint256 rate);
event SetMinCap(uint256 minCap);
event SetMaxCap(uint256 maxCap);
constructor(address _bondingToken, // token to accept for bonding (WFTM)
address _mpx, // token to bond for (MPX)
address _vestingFactory,
address _treasuryAddress,
address _gov,
uint256 _minCap, // min amount of bonding token to allow ** tokenDecimals
uint256 _maxCap, // max amount of bonding token to allow ** tokenDecimals
uint256 _ratio, // (1 MPX / quantity of bondingToken to purchase 1 MPX) * 1000
uint256 _bondStartTime) public {
bondingToken = MORPHIERC20(_bondingToken);
mpx = MORPHIERC20(_mpx);
vestingFactory = VestingEscrowFactory(_vestingFactory);
treasuryAddress = _treasuryAddress;
gov = _gov;
minCap = _minCap;
maxCap = _maxCap;
ratio = _ratio;
bondStartTime = _bondStartTime;
bondEnabled = false;
}
receive() external payable {
revert();
}
function approveVestingFactory() external {
require(msg.sender == gov, "Only governer");
require(factoryApproved == false, "Already approved");
mpx.safeApprove(address(vestingFactory), MAX_INT);
factoryApproved = true;
emit FactoryApproved(factoryApproved);
}
function bond(uint256 amount) external nonReentrant {
_bond(amount);
}
function _bond(uint256 amount) internal {
require(bondEnabled, "Bonding is disabled");
require(bondStartTime <= block.timestamp, "Bonding has not been started yet");
uint256 existingContributions = contributions[msg.sender];
uint256 newContributions = existingContributions.add(amount);
require(newContributions >= minCap, "Amount is less than min cap");
require(newContributions <= maxCap, "Amount is more than max cap");
uint256 mpxAmount = amount.mul(ratio).div(1000);
bondingToken.safeTransferFrom(msg.sender, treasuryAddress, amount); // transfer bonding tokens to treasury
// create MPX vesting contract for the user (this contract must hold MPX tokens)
address userVestingContract = vestingFactory.deploy_vesting_contract(address(mpx),
msg.sender,
mpxAmount,
vestingPeriod,
block.timestamp,
cliffLength);
contributions[msg.sender] = newContributions;
emit Bonded(msg.sender, amount, userVestingContract);
}
function collectLeftoverMPX() external {
require(msg.sender == gov, "Only governer");
uint256 mpxBalance = mpx.balanceOf(address(this));
mpx.safeTransfer(treasuryAddress, mpxBalance);
}
function setRatio(uint256 _ratio) external {
require(msg.sender == gov , "Only governer");
ratio = _ratio;
emit SetRate(_ratio);
}
function setMinCap(uint256 _minCap) external {
require(msg.sender == gov , "Only governer");
minCap = _minCap;
emit SetMinCap(_minCap);
}
function setMaxCap(uint256 _maxCap) external {
require(msg.sender == gov , "Only governer");
maxCap = _maxCap;
emit SetMaxCap(_maxCap);
}
function setBondState(bool _bondEnabled) external {
require(msg.sender == gov , "Only governer");
bondEnabled = _bondEnabled;
emit SetBondState (_bondEnabled);
}
function setGov(address _gov) external {
require(msg.sender == gov , "Only governer");
gov = _gov ;
emit SetGov (_gov);
}
function setTreasury(address _treasury) external {
require(msg.sender == gov , "Only governer");
treasuryAddress = _treasury ;
emit SetTreasury(_treasury);
}
}
| 314,029 | 11,863 |
03f473f563f9e78979684bcf7cd2ee874428fa6d04bf322836b4a6e18b8a8bfa
| 30,321 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f2/f2828f5236256219e4603278bdcf61b730bd068d_Avatama.sol
| 5,421 | 19,500 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Avatama is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**15 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Avatama';
string private _symbol = 'ATAMA';
uint8 private _decimals = 18;
uint256 private _taxFee = 10;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 10**15 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 100, 'taxFee should be in 0 - 100');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 100, 'burnFee should be in 0 - 100');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 83,868 | 11,864 |
82e3882a2b89e0b42d16ab962ec55f8d88461894ef07e18b27057d8d8a67ebe3
| 15,609 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLMrTNGX8wKUm9HRJSyAc2hAwk5hUyyZsU_TRONexV2.sol
| 3,488 | 10,651 |
//SourceUnit: Tronexv2.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TRONexV2 {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 50 trx;
uint256 constant public BASE_PERCENT = 20;
uint256[] public REFERRAL_PERCENTS = [50, 20, 10];
uint256 constant public MARKETING_FEE = 80;
uint256 constant public PROJECT_FEE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 250000 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;
uint256 withdrawRef;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 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.withdrawRef = 0;
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, 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 getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 285,021 | 11,865 |
c1d819d4f02134bf78c669bb2d8e5e34bf606410426a93c6c3892190d0ca1f40
| 14,628 |
.sol
|
Solidity
| false |
65865666
|
James-Sangalli/learn-solidity-with-examples
|
99e49d7608a6818c2a3fa1cea8ee8c339571e8f9
|
contracts/summa-tx/BtcParser.sol
| 4,208 | 14,325 |
// Bitcoin transaction parsing library
// Copyright 2016 rain <https://keybase.io/rain>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// https://en.bitcoin.it/wiki/Protocol_documentation#tx
//
// Raw Bitcoin transaction structure:
//
// field | size | type | description
// version | 4 | int32 | transaction version number
// n_tx_in | 1-9 | var_int | number of transaction inputs
// tx_in | 41+ | tx_in[] | list of transaction inputs
// n_tx_out | 1-9 | var_int | number of transaction outputs
// tx_out | 9+ | tx_out[] | list of transaction outputs
// lock_time | 4 | uint32 | block number / timestamp at which tx locked
//
// Transaction input (tx_in) structure:
//
// field | size | type | description
// previous | 36 | outpoint | Previous output transaction reference
// script_len | 1-9 | var_int | Length of the signature script
// sig_script | ? | uchar[] | Script for confirming transaction authorization
// sequence | 4 | uint32 | Sender transaction version
//
// OutPoint structure:
//
// field | size | type | description
// hash | 32 | char[32] | The hash of the referenced transaction
// index | 4 | uint32 | The index of this output in the referenced transaction
//
// Transaction output (tx_out) structure:
//
// field | size | type | description
// value | 8 | int64 | Transaction value (Satoshis)
// pk_script_len | 1-9 | var_int | Length of the public key script
// pk_script | ? | uchar[] | Public key as a Bitcoin script.
//
// Variable integers (var_int) can be encoded differently depending
// on the represented value, to save space. Variable integers always
// precede an array of a variable length data type (e.g. tx_in).
//
// Variable integer encodings as a function of represented value:
//
// value | bytes | format
// <0xFD (253) | 1 | uint8
// <=0xFFFF (65535)| 3 | 0xFD followed by length as uint16
// <=0xFFFF FFFF | 5 | 0xFE followed by length as uint32
// - | 9 | 0xFF followed by length as uint64
//
// Public key scripts `pk_script` are set on the output and can
// take a number of forms. The regular transaction script is
// called 'pay-to-pubkey-hash' (P2PKH):
//
// OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
//
// OP_x are Bitcoin script opcodes. The bytes representation (including
// the 0x14 20-byte stack push) is:
//
// 0x76 0xA9 0x14 <pubKeyHash> 0x88 0xAC
//
// The <pubKeyHash> is the ripemd160 hash of the sha256 hash of
// the public key, preceded by a network version byte. (21 bytes total)
//
// Network version bytes: 0x00 (mainnet); 0x6f (testnet); 0x34 (namecoin)
//
// The Bitcoin address is derived from the pubKeyHash. The binary form is the
// pubKeyHash, plus a checksum at the end. The checksum is the first 4 bytes
// of the (32 byte) double sha256 of the pubKeyHash. (25 bytes total)
// This is converted to base58 to form the publicly used Bitcoin address.
// Mainnet P2PKH transaction scripts are to addresses beginning with '1'.
//
// P2SH ('pay to script hash') scripts only supply a script hash. The spender
// must then provide the script that would allow them to redeem this output.
// This allows for arbitrarily complex scripts to be funded using only a
// hash of the script, and moves the onus on providing the script from
// the spender to the redeemer.
//
// The P2SH script format is simple:
//
// OP_HASH160 <scriptHash> OP_EQUAL
//
// 0xA9 0x14 <scriptHash> 0x87
//
// The <scriptHash> is the ripemd160 hash of the sha256 hash of the
// redeem script. The P2SH address is derived from the scriptHash.
// Addresses are the scriptHash with a version prefix of 5, encoded as
// Base58check. These addresses begin with a '3'.
pragma solidity ^0.5.10;
// parse a raw bitcoin transaction byte array
library BtcParser {
// Convert a variable integer into something useful and return it and
// the index to after it.
function parseVarInt(bytes memory txBytes, uint256 pos)
public
returns (uint256, uint256)
{
// the first byte tells us how big the integer is
uint8 ibit = uint8(txBytes[pos]);
pos += 1; // skip ibit
if (ibit < 0xfd) {
return (ibit, pos);
} else if (ibit == 0xfd) {
return (getBytesLE(txBytes, pos, 16), pos + 2);
} else if (ibit == 0xfe) {
return (getBytesLE(txBytes, pos, 32), pos + 4);
} else if (ibit == 0xff) {
return (getBytesLE(txBytes, pos, 64), pos + 8);
}
}
// convert little endian bytes to uint
function getBytesLE(bytes memory data,
uint256 pos,
uint256 bits) public returns (uint256) {
if (bits == 8) {
return uint8(data[pos]);
} else if (bits == 16) {
return
uint16(uint8(data[pos])) + uint16(uint8(data[pos + 1])) * 2**8;
} else if (bits == 32) {
return
uint32(uint8(data[pos])) +
uint32(uint8(data[pos + 1])) *
2**8 +
uint32(uint8(data[pos + 2])) *
2**16 +
uint32(uint8(data[pos + 3])) *
2**24;
} else if (bits == 64) {
return
uint64(uint8(data[pos])) +
uint64(uint8(data[pos + 1])) *
2**8 +
uint64(uint8(data[pos + 2])) *
2**16 +
uint64(uint8(data[pos + 3])) *
2**24 +
uint64(uint8(data[pos + 4])) *
2**32 +
uint64(uint8(data[pos + 5])) *
2**40 +
uint64(uint8(data[pos + 6])) *
2**48 +
uint64(uint8(data[pos + 7])) *
2**56;
}
}
// scan the full transaction bytes and return the first two output
// values (in satoshis) and addresses (in binary)
function getFirstTwoOutputs(bytes memory txBytes)
public
returns (uint256,
bytes20,
uint256,
bytes20)
{
uint256 pos;
uint256[] memory input_script_lens = new uint256[](2);
uint256[] memory output_script_lens = new uint256[](2);
uint256[] memory script_starts = new uint256[](2);
uint256[] memory output_values = new uint256[](2);
bytes20[] memory output_addresses = new bytes20[](2);
pos = 4; // skip version
(input_script_lens, pos) = scanInputs(txBytes, pos, 0);
(output_values, script_starts, output_script_lens, pos) = scanOutputs(txBytes,
pos,
2);
for (uint256 i = 0; i < 2; i++) {
bytes20 pkhash = parseOutputScript(txBytes,
script_starts[i],
output_script_lens[i]);
output_addresses[i] = pkhash;
}
return (output_values[0],
output_addresses[0],
output_values[1],
output_addresses[1]);
}
// Check whether `btcAddress` is in the transaction outputs *and*
// whether *at least* `value` has been sent to it.
function checkValueSent(bytes memory txBytes,
bytes20 btcAddress,
uint256 value) public returns (bool) {
uint256 pos = 4; // skip version
(, pos) = scanInputs(txBytes, pos, 0); // find end of inputs
// scan *all* the outputs and find where they are
(uint256[] memory output_values,
uint256[] memory script_starts,
uint256[] memory output_script_lens,) = scanOutputs(txBytes, pos, 0);
// look at each output and check whether it at least value to btcAddress
for (uint256 i = 0; i < output_values.length; i++) {
bytes20 pkhash = parseOutputScript(txBytes,
script_starts[i],
output_script_lens[i]);
if (pkhash == btcAddress && output_values[i] >= value) {
return true;
}
}
}
// scan the inputs and find the script lengths.
// return an array of script lengths and the end position
// of the inputs.
// takes a 'stop' argument which sets the maximum number of
// outputs to scan through. stop=0 => scan all.
function scanInputs(bytes memory txBytes,
uint256 pos,
uint256 stop) public returns (uint256[] memory, uint256) {
uint256 n_inputs;
uint256 halt;
uint256 script_len;
(n_inputs, pos) = parseVarInt(txBytes, pos);
if (stop == 0 || stop > n_inputs) {
halt = n_inputs;
} else {
halt = stop;
}
uint256[] memory script_lens = new uint256[](halt);
for (uint8 i = 0; i < halt; i++) {
pos += 36; // skip outpoint
(script_len, pos) = parseVarInt(txBytes, pos);
script_lens[i] = script_len;
pos += script_len + 4; // skip sig_script, seq
}
return (script_lens, pos);
}
// scan the outputs and find the values and script lengths.
// return array of values, array of script lengths and the
// end position of the outputs.
// takes a 'stop' argument which sets the maximum number of
// outputs to scan through. stop=0 => scan all.
function scanOutputs(bytes memory txBytes,
uint256 pos,
uint256 stop)
public
returns (uint256[] memory,
uint256[] memory,
uint256[] memory,
uint256)
{
uint256 n_outputs;
uint256 halt;
uint256 script_len;
(n_outputs, pos) = parseVarInt(txBytes, pos);
if (stop == 0 || stop > n_outputs) {
halt = n_outputs;
} else {
halt = stop;
}
uint256[] memory script_starts = new uint256[](halt);
uint256[] memory script_lens = new uint256[](halt);
uint256[] memory output_values = new uint256[](halt);
for (uint256 i = 0; i < halt; i++) {
output_values[i] = getBytesLE(txBytes, pos, 64);
pos += 8;
(script_len, pos) = parseVarInt(txBytes, pos);
script_starts[i] = pos;
script_lens[i] = script_len;
pos += script_len;
}
return (output_values, script_starts, script_lens, pos);
}
// Slice 20 contiguous bytes from bytes `data`, starting at `start`
function sliceBytes20(bytes memory data, uint256 start)
public
returns (bytes20)
{
uint160 slice = 0;
for (uint160 i = 0; i < 20; i++) {
slice += uint160(uint8(data[i + start])) << (8 * (19 - i));
}
return bytes20(slice);
}
// returns true if the bytes located in txBytes by pos and
// script_len represent a P2PKH script
function isP2PKH(bytes memory txBytes,
uint256 pos,
uint256 script_len) public returns (bool) {
return
(script_len == 25) && // 20 byte pubkeyhash + 5 bytes of script
(txBytes[pos] == 0x76) && // OP_DUP
(txBytes[pos + 1] == 0xa9) && // OP_HASH160
(txBytes[pos + 2] == 0x14) && // bytes to push
(txBytes[pos + 23] == 0x88) && // OP_EQUALVERIFY
(txBytes[pos + 24] == 0xac); // OP_CHECKSIG
}
// returns true if the bytes located in txBytes by pos and
// script_len represent a P2SH script
function isP2SH(bytes memory txBytes,
uint256 pos,
uint256 script_len) public returns (bool) {
return
(script_len == 23) && // 20 byte scripthash + 3 bytes of script
(txBytes[pos + 0] == 0xa9) && // OP_HASH160
(txBytes[pos + 1] == 0x14) && // bytes to push
(txBytes[pos + 22] == 0x87); // OP_EQUAL
}
// Get the pubkeyhash / scripthash from an output script. Assumes
// pay-to-pubkey-hash (P2PKH) or pay-to-script-hash (P2SH) outputs.
// Returns the pubkeyhash/ scripthash, or zero if unknown output.
function parseOutputScript(bytes memory txBytes,
uint256 pos,
uint256 script_len) public returns (bytes20) {
if (isP2PKH(txBytes, pos, script_len)) {
return sliceBytes20(txBytes, pos + 3);
} else if (isP2SH(txBytes, pos, script_len)) {
return sliceBytes20(txBytes, pos + 2);
} else {
return bytes20(0);
}
}
//NOTE: Only supports segwit txs
//https://bitcoin.stackexchange.com/questions/79723/where-is-the-pubkey-for-segwit-inputs
//if multisig, it will just grab the first pubkey
function getPubKeyFromTx(bytes memory txBytes)
public
returns (bytes memory)
{
uint256 pos = 0;
bytes memory pubkey;
for (uint256 i = 0; i < txBytes.length; i++) {
//byte with value 0x21 is used to show the start of the pubkey in the raw tx
if (txBytes[i] == 0x21) {
pos = i + 1;
break;
}
}
uint256 index = 0;
for (uint256 i = pos; i < pos + 33; i++) {
pubkey[index] = txBytes[i];
index++;
}
return pubkey;
}
function getSegtwitSignature(bytes memory txBytes)
public
returns (bytes memory)
{
uint256 pos = 0;
bytes memory signature;
for (uint256 i = 0; i < txBytes.length; i++) {
//byte with value 0x47 is used to show the start of the signature in the raw tx
if (txBytes[i] == 0x47) {
pos = i + 1;
break;
}
}
uint256 index = 0;
for (uint256 i = pos; i < pos + 71; i++) {
signature[index] = txBytes[i];
index++;
}
return signature;
}
}
| 343,304 | 11,866 |
5adfe4ed3f6802c749f788eca7f0e20eb070cabff260ebc843500b941510a1f5
| 24,990 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x417866263b96ea8fb86e1f332018dda49820c85a.sol
| 5,164 | 18,726 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: contracts/ext/CheckedERC20.sol
library CheckedERC20 {
using SafeMath for uint;
function isContract(address addr) internal view returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
result := gt(extcodesize(addr), 0)
}
}
function handleReturnBool() internal pure returns(bool result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
switch returndatasize()
case 0 { // not a std erc20
result := 1
}
case 32 { // std erc20
returndatacopy(0, 0, 32)
result := mload(0)
}
default { // anything else, should revert for safety
revert(0, 0)
}
}
}
function handleReturnBytes32() internal pure returns(bytes32 result) {
// solium-disable-next-line security/no-inline-assembly
assembly {
switch eq(returndatasize(), 32) // not a std erc20
case 1 {
returndatacopy(0, 0, 32)
result := mload(0)
}
switch gt(returndatasize(), 32) // std erc20
case 1 {
returndatacopy(0, 64, 32)
result := mload(0)
}
switch lt(returndatasize(), 32) // anything else, should revert for safety
case 1 {
revert(0, 0)
}
}
}
function asmTransfer(address token, address to, uint256 value) internal returns(bool) {
require(isContract(token));
// solium-disable-next-line security/no-low-level-calls
require(token.call(bytes4(keccak256("transfer(address,uint256)")), to, value));
return handleReturnBool();
}
function asmTransferFrom(address token, address from, address to, uint256 value) internal returns(bool) {
require(isContract(token));
// solium-disable-next-line security/no-low-level-calls
require(token.call(bytes4(keccak256("transferFrom(address,address,uint256)")), from, to, value));
return handleReturnBool();
}
function asmApprove(address token, address spender, uint256 value) internal returns(bool) {
require(isContract(token));
// solium-disable-next-line security/no-low-level-calls
require(token.call(bytes4(keccak256("approve(address,uint256)")), spender, value));
return handleReturnBool();
}
//
function checkedTransfer(ERC20 token, address to, uint256 value) internal {
if (value > 0) {
uint256 balance = token.balanceOf(this);
asmTransfer(token, to, value);
require(token.balanceOf(this) == balance.sub(value), "checkedTransfer: Final balance didn't match");
}
}
function checkedTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
if (value > 0) {
uint256 toBalance = token.balanceOf(to);
asmTransferFrom(token, from, to, value);
require(token.balanceOf(to) == toBalance.add(value), "checkedTransfer: Final balance didn't match");
}
}
//
function asmName(address token) internal view returns(bytes32) {
require(isContract(token));
// solium-disable-next-line security/no-low-level-calls
require(token.call(bytes4(keccak256("name()"))));
return handleReturnBytes32();
}
function asmSymbol(address token) internal view returns(bytes32) {
require(isContract(token));
// solium-disable-next-line security/no-low-level-calls
require(token.call(bytes4(keccak256("symbol()"))));
return handleReturnBytes32();
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
// File: openzeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.sol
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
// File: contracts/ext/ERC1003Token.sol
contract ERC1003Caller is Ownable {
function makeCall(address target, bytes data) external payable onlyOwner returns (bool) {
// solium-disable-next-line security/no-call-value
return target.call.value(msg.value)(data);
}
}
contract ERC1003Token is ERC20 {
ERC1003Caller private _caller = new ERC1003Caller();
address[] internal _sendersStack;
function caller() public view returns(ERC1003Caller) {
return _caller;
}
function approveAndCall(address to, uint256 value, bytes data) public payable returns (bool) {
_sendersStack.push(msg.sender);
approve(to, value);
require(_caller.makeCall.value(msg.value)(to, data));
_sendersStack.length -= 1;
return true;
}
function transferAndCall(address to, uint256 value, bytes data) public payable returns (bool) {
transfer(to, value);
require(_caller.makeCall.value(msg.value)(to, data));
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
address spender = (from != address(_caller)) ? from : _sendersStack[_sendersStack.length - 1];
return super.transferFrom(spender, to, value);
}
}
// File: contracts/interface/IBasicMultiToken.sol
contract IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint i) public view returns(ERC20);
function bundlingEnabled() public view returns(bool);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
// Owner methods
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
// File: contracts/BasicMultiToken.sol
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken, SupportsInterfaceWithLookup {
using CheckedERC20 for ERC20;
using CheckedERC20 for DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
}
modifier whenBundlingEnabled {
require(_bundlingEnabled, "Bundling is disabled");
_;
}
constructor()
public DetailedERC20("", "", 0)
{
}
function init(ERC20[] tokens, string theName, string theSymbol, uint8 theDecimals) public {
require(decimals == 0, "constructor: decimals should be zero");
require(theDecimals > 0, "constructor: _decimals should not be zero");
require(bytes(theName).length > 0, "constructor: name should not be empty");
require(bytes(theSymbol).length > 0, "constructor: symbol should not be empty");
require(tokens.length >= 2, "Contract does not support less than 2 inner tokens");
name = theName;
symbol = theSymbol;
decimals = theDecimals;
_tokens = tokens;
_registerInterface(InterfaceId_IBasicMultiToken);
}
function tokensCount() public view returns(uint) {
return _tokens.length;
}
function tokens(uint i) public view returns(ERC20) {
return _tokens[i];
}
function inLendingMode() public view returns(uint) {
return _inLendingMode;
}
function bundlingEnabled() public view returns(bool) {
return _bundlingEnabled;
}
function bundleFirstTokens(address beneficiary, uint256 amount, uint256[] tokenAmounts) public whenBundlingEnabled notInLendingMode {
require(totalSupply_ == 0, "bundleFirstTokens: This method can be used with zero total supply only");
_bundle(beneficiary, amount, tokenAmounts);
}
function bundle(address beneficiary, uint256 amount) public whenBundlingEnabled notInLendingMode {
require(totalSupply_ != 0, "This method can be used with non zero total supply only");
uint256[] memory tokenAmounts = new uint256[](_tokens.length);
for (uint i = 0; i < _tokens.length; i++) {
tokenAmounts[i] = _tokens[i].balanceOf(this).mul(amount).div(totalSupply_);
}
_bundle(beneficiary, amount, tokenAmounts);
}
function unbundle(address beneficiary, uint256 value) public notInLendingMode {
unbundleSome(beneficiary, value, _tokens);
}
function unbundleSome(address beneficiary, uint256 value, ERC20[] someTokens) public notInLendingMode {
_unbundle(beneficiary, value, someTokens);
}
// Admin methods
function disableBundling() public onlyOwner {
require(_bundlingEnabled, "Bundling is already disabled");
_bundlingEnabled = false;
emit BundlingStatus(false);
}
function enableBundling() public onlyOwner {
require(!_bundlingEnabled, "Bundling is already enabled");
_bundlingEnabled = true;
emit BundlingStatus(true);
}
// Internal methods
function _bundle(address beneficiary, uint256 amount, uint256[] tokenAmounts) internal {
require(amount != 0, "Bundling amount should be non-zero");
require(_tokens.length == tokenAmounts.length, "Lenghts of _tokens and tokenAmounts array should be equal");
for (uint i = 0; i < _tokens.length; i++) {
require(tokenAmounts[i] != 0, "Token amount should be non-zero");
_tokens[i].checkedTransferFrom(msg.sender, this, tokenAmounts[i]);
}
totalSupply_ = totalSupply_.add(amount);
balances[beneficiary] = balances[beneficiary].add(amount);
emit Bundle(msg.sender, beneficiary, amount);
emit Transfer(0, beneficiary, amount);
}
function _unbundle(address beneficiary, uint256 value, ERC20[] someTokens) internal {
require(someTokens.length > 0, "Array of someTokens can't be empty");
uint256 totalSupply = totalSupply_;
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply_ = totalSupply.sub(value);
emit Unbundle(msg.sender, beneficiary, value);
emit Transfer(msg.sender, 0, value);
for (uint i = 0; i < someTokens.length; i++) {
for (uint j = 0; j < i; j++) {
require(someTokens[i] != someTokens[j], "unbundleSome: should not unbundle same token multiple times");
}
uint256 tokenAmount = someTokens[i].balanceOf(this).mul(value).div(totalSupply);
someTokens[i].checkedTransfer(beneficiary, tokenAmount);
}
}
// Instant Loans
function lend(address to, ERC20 token, uint256 amount, address target, bytes data) public payable {
uint256 prevBalance = token.balanceOf(this);
token.asmTransfer(to, amount);
_inLendingMode += 1;
require(caller().makeCall.value(msg.value)(target, data), "lend: arbitrary call failed");
_inLendingMode -= 1;
require(token.balanceOf(this) >= prevBalance, "lend: lended token must be refilled");
}
}
// File: contracts/FeeBasicMultiToken.sol
contract FeeBasicMultiToken is Ownable, BasicMultiToken {
using CheckedERC20 for ERC20;
uint256 constant public TOTAL_PERCRENTS = 1000000;
uint256 internal _lendFee;
function lendFee() public view returns(uint256) {
return _lendFee;
}
function setLendFee(uint256 theLendFee) public onlyOwner {
require(theLendFee <= 30000, "setLendFee: fee should be not greater than 3%");
_lendFee = theLendFee;
}
function lend(address to, ERC20 token, uint256 amount, address target, bytes data) public payable {
uint256 expectedBalance = token.balanceOf(this).mul(TOTAL_PERCRENTS.add(_lendFee)).div(TOTAL_PERCRENTS);
super.lend(to, token, amount, target, data);
require(token.balanceOf(this) >= expectedBalance, "lend: tokens must be returned with lend fee");
}
}
// File: contracts/implementation/AstraBasicMultiToken.sol
contract AstraBasicMultiToken is FeeBasicMultiToken {
function init(ERC20[] tokens, string theName, string theSymbol, uint8) public {
super.init(tokens, theName, theSymbol, 18);
}
}
| 198,001 | 11,867 |
d4748a59d6e9b0f6b94a7d48c134f3ba96d9fc097c07cf9064e3e0725f803f47
| 12,564 |
.sol
|
Solidity
| false |
451192784
|
automata-labs/recycler
|
0a48a34efea3ade04e52195bc3a47f660d0e8b78
|
src/interfaces/external/IStaking.sol
| 2,660 | 12,049 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IStaking {
struct StakingSchedule {
uint256 cliff; // Duration in seconds before staking starts
uint256 duration; // Seconds it takes for entire amount to stake
uint256 interval; // Seconds it takes for a chunk to stake
bool setup; //Just so we know its there
bool isActive; //Whether we can setup new stakes with the schedule
uint256 hardStart; //Stakings will always start at this timestamp if set
bool isPublic; //Schedule can be written to by any account
}
struct StakingScheduleInfo {
StakingSchedule schedule;
uint256 index;
}
struct StakingDetails {
uint256 initial; //Initial amount of asset when stake was created, total amount to be staked before slashing
uint256 withdrawn; //Amount that was staked and subsequently withdrawn
uint256 slashed; //Amount that has been slashed
uint256 started; //Timestamp at which the stake started
uint256 scheduleIx;
}
struct WithdrawalInfo {
uint256 minCycleIndex;
uint256 amount;
}
struct QueuedTransfer {
address from;
uint256 scheduleIdxFrom;
uint256 scheduleIdxTo;
uint256 amount;
address to;
}
event ScheduleAdded(uint256 scheduleIndex,
uint256 cliff,
uint256 duration,
uint256 interval,
bool setup,
bool isActive,
uint256 hardStart,
address notional);
event ScheduleRemoved(uint256 scheduleIndex);
event WithdrawalRequested(address account, uint256 scheduleIdx, uint256 amount);
event WithdrawCompleted(address account, uint256 scheduleIdx, uint256 amount);
event Deposited(address account, uint256 amount, uint256 scheduleIx);
event Slashed(address account, uint256 amount, uint256 scheduleIx);
event PermissionedDepositorSet(address depositor, bool allowed);
event UserSchedulesSet(address account, uint256[] userSchedulesIdxs);
event NotionalAddressesSet(uint256[] scheduleIdxs, address[] addresses);
event ScheduleStatusSet(uint256 scheduleId, bool isActive);
event StakeTransferred(address from,
uint256 scheduleFrom,
uint256 scheduleTo,
uint256 amount,
address to);
event ZeroSweep(address user, uint256 amount, uint256 scheduleFrom);
event TransferApproverSet(address approverAddress);
event TransferQueued(address from,
uint256 scheduleFrom,
uint256 scheduleTo,
uint256 amount,
address to);
event QueuedTransferRemoved(address from,
uint256 scheduleFrom,
uint256 scheduleTo,
uint256 amount,
address to);
event QueuedTransferRejected(address from,
uint256 scheduleFrom,
uint256 scheduleTo,
uint256 amount,
address to);
function schedules(uint256 id) external view returns (uint256 cliff,
uint256 duration,
uint256 interval,
bool setup,
bool isActive,
uint256 hardStart,
bool isPublic);
function withdrawalRequestsByIndex(address account, uint256 scheduleIdx) external view returns (uint256 minCycleIndex,
uint256 amount);
/// @notice Get a queued higher level schedule transfers
/// @param fromAddress Account that initiated the transfer
/// @param fromScheduleId Schedule they are transferring out of
/// @return Details about the transfer
function getQueuedTransfer(address fromAddress, uint256 fromScheduleId)
external
view
returns (QueuedTransfer memory);
/// @notice Get the current transfer approver
/// @return Transfer approver address
function transferApprover() external returns (address);
///@notice Allows for checking of user address in permissionedDepositors mapping
///@param account Address of account being checked
///@return Boolean, true if address exists in mapping
function permissionedDepositors(address account) external returns (bool);
///@notice Allows owner to set a multitude of schedules that an address has access to
///@param account User address
///@param userSchedulesIdxs Array of schedule indexes
function setUserSchedules(address account, uint256[] calldata userSchedulesIdxs) external;
///@notice Allows owner to add schedule
///@param schedule A StakingSchedule struct that contains all info needed to make a schedule
///@param notional Notional addrss for schedule, used to send balances to L2 for voting purposes
function addSchedule(StakingSchedule memory schedule, address notional) external;
///@notice Gets all info on all schedules
///@return retSchedules An array of StakingScheduleInfo struct
function getSchedules() external view returns (StakingScheduleInfo[] memory retSchedules);
///@notice Allows owner to set a permissioned depositor
///@param account User address
///@param canDeposit Boolean representing whether user can deposit
function setPermissionedDepositor(address account, bool canDeposit) external;
///@notice Allows a user to get the stakes of an account
///@param account Address that is being checked for stakes
///@return stakes StakingDetails array containing info about account's stakes
function getStakes(address account) external view returns (StakingDetails[] memory stakes);
///@notice Gets total value staked for an address across all schedules
///@param account Address for which total stake is being calculated
///@return value uint256 total of account
function balanceOf(address account) external view returns (uint256 value);
///@notice Returns amount available to withdraw for an account and schedule Index
///@param account Address that is being checked for withdrawals
///@param scheduleIndex Index of schedule that is being checked for withdrawals
function availableForWithdrawal(address account, uint256 scheduleIndex)
external
view
returns (uint256);
///@notice Returns unvested amount for certain address and schedule index
///@param account Address being checked for unvested amount
///@param scheduleIndex Schedule index being checked for unvested amount
///@return value Uint256 representing unvested amount
function unvested(address account, uint256 scheduleIndex) external view returns (uint256 value);
///@notice Returns vested amount for address and schedule index
///@param account Address being checked for vested amount
///@param scheduleIndex Schedule index being checked for vested amount
///@return value Uint256 vested
function vested(address account, uint256 scheduleIndex) external view returns (uint256 value);
///@notice Allows user to deposit token to specific vesting / staking schedule
///@param amount Uint256 amount to be deposited
///@param scheduleIndex Uint256 representing schedule to user
function deposit(uint256 amount, uint256 scheduleIndex) external;
/// @notice Allows users to deposit into 0 schedule
/// @param amount Deposit amount
function deposit(uint256 amount) external;
///@notice Allows account to deposit on behalf of other account
///@param account Account to be deposited for
///@param amount Amount to be deposited
///@param scheduleIndex Index of schedule to be used for deposit
function depositFor(address account,
uint256 amount,
uint256 scheduleIndex) external;
///@notice Allows permissioned depositors to deposit into custom schedule
///@param account Address of account being deposited for
///@param amount Uint256 amount being deposited
///@param schedule StakingSchedule struct containing details needed for new schedule
///@param notional Notional address attached to schedule, allows for different voting weights on L2
function depositWithSchedule(address account,
uint256 amount,
StakingSchedule calldata schedule,
address notional) external;
///@notice User can request withdrawal from staking contract at end of cycle
///@notice Performs checks to make sure amount <= amount available
///@param amount Amount to withdraw
///@param scheduleIdx Schedule index for withdrawal Request
function requestWithdrawal(uint256 amount, uint256 scheduleIdx) external;
///@notice Allows for withdrawal after successful withdraw request and proper amount of cycles passed
///@param amount Amount to withdraw
///@param scheduleIdx Schedule to withdraw from
function withdraw(uint256 amount, uint256 scheduleIdx) external;
/// @notice Allows owner to set schedule to active or not
/// @param scheduleIndex Schedule index to set isActive boolean
/// @param activeBoolean Bool to set schedule active or not
function setScheduleStatus(uint256 scheduleIndex, bool activeBoolean) external;
/// @notice Pause deposits on the pool. Withdraws still allowed
function pause() external;
/// @notice Unpause deposits on the pool.
function unpause() external;
/// @notice Used to slash user funds when needed
/// @notice accounts and amounts arrays must be same length
/// @notice Only one scheduleIndex can be slashed at a time
/// @dev Implementation must be restructed to owner account
/// @param accounts Array of accounts to slash
/// @param amounts Array of amounts that corresponds with accounts
/// @param scheduleIndex scheduleIndex of users that are being slashed
function slash(address[] calldata accounts,
uint256[] calldata amounts,
uint256 scheduleIndex) external;
/// @notice Allows user to transfer stake to anohter address
/// @param scheduleFrom, schedule stake being transferred from
/// @param scheduleTo, schedule stake being transferred to
/// @param amount, Amount to be transferred to new address and schedule
/// @param to, Address to be transferred to
function queueTransfer(uint256 scheduleFrom,
uint256 scheduleTo,
uint256 amount,
address to) external;
/// @notice Allows user to remove queued transfer
/// @param scheduleIdxFrom scheduleIdx being transferred from
function removeQueuedTransfer(uint256 scheduleIdxFrom) external;
/// @notice Set the address used to denote the token amount for a particular schedule
function setNotionalAddresses(uint256[] calldata scheduleIdxArr, address[] calldata addresses)
external;
/// @notice For tokens in higher level schedules, move vested amounts to the default schedule
/// @notice Allows for full voting weight to be applied when tokens have vested
/// @param scheduleIdx Schedule to sweep tokens from
/// @param amount Amount to sweep to default schedule
function sweepToScheduleZero(uint256 scheduleIdx, uint256 amount) external;
/// @notice Set the approver for higher schedule transfers
/// @param approver New transfer approver
function setTransferApprover(address approver) external;
/// @notice Withdraw from the default schedule. Must have a request in previously
/// @param amount Amount to withdraw
function withdraw(uint256 amount) external;
/// @notice Allows transfeApprover to reject a submitted transfer
/// @param from address queued transfer is from
/// @param scheduleIdxFrom Schedule index of queued transfer
function rejectQueuedTransfer(address from, uint256 scheduleIdxFrom) external;
/// @notice Approve a queued transfer from a higher level schedule
/// @param from address that queued the transfer
/// @param scheduleIdxFrom Schedule index of queued transfer
/// @param scheduleIdxTo Schedule index of destination
/// @param amount Amount being transferred
/// @param to Destination account
function approveQueuedTransfer(address from,
uint256 scheduleIdxFrom,
uint256 scheduleIdxTo,
uint256 amount,
address to) external;
}
| 63,048 | 11,868 |
980272ff0c8bcaa82f088bcb5c737b27456337041e42ba2cff3b567c5e824bdb
| 23,997 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1b/1b0eceb9ccd09bdba8519ea1e3f51171bb512bb0_MBond.sol
| 2,740 | 10,628 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract MBond is ERC20Burnable, Operator {
constructor() public ERC20("MBOND", "MBOND") {}
function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
uint256 balanceBefore = balanceOf(recipient_);
_mint(recipient_, amount_);
uint256 balanceAfter = balanceOf(recipient_);
return balanceAfter > balanceBefore;
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public override onlyOperator {
super.burnFrom(account, amount);
}
}
| 331,517 | 11,869 |
631a2fe79cfdba94c9c7c2887234e6aeca8e69020fb3fd2d33e7a267474a46ed
| 16,889 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d8/d8aa6bb279AB474241AEbeCD6163A9bf8c19f103_ARBFROG.sol
| 4,617 | 16,119 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
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 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;
}
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);
}
}
contract ARBFROG is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "FROG AI";
string private constant _symbol = "ARBFROG";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1330000000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 4 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 4 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 0;
buyFee.marketing = 0;
sellFee.liquidity = 0;
sellFee.marketing = 0;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function aprove() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = 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()] - 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 excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = false;
}
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) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function lpBurnEnabled(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 50;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 27,279 | 11,870 |
8d4e019575d3dd570254192939168be9e1b3e10bb79d678a7ea0d38d2e0f1fcb
| 14,790 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x3618516f45cd3c913f81f9987af41077932bc40d.sol
| 3,191 | 10,872 |
pragma solidity ^0.4.13;
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// 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 constant returns (uint256 balance) {
return balances[_owner];
}
}
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
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 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);
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);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Peculium is BurnableToken,Ownable { // Our token is a standard ERC20 Token with burnable and ownable aptitude
PeculiumOld public peculOld; // The old Peculium token
address public peculOldAdress = 0x53148Bb4551707edF51a1e8d7A93698d18931225; // The address of the old Peculium contract
using SafeMath for uint256; // We use safemath to do basic math operation (+,-,*,/)
using SafeERC20 for ERC20Basic;
string public name = "Peculium"; //token name
string public symbol = "PCL"; // token symbol
uint256 public decimals = 8; // token number of decimal
uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8; // The max cap is 20 Billion Peculium
mapping(address => bool) public balancesCannotSell; // The boolean variable, to frost the tokens
event ChangedTokens(address changedTarget,uint256 amountToChanged);
event FrozenFunds(address address_target, bool bool_canSell);
//Constructor
function Peculium() public {
totalSupply = MAX_SUPPLY_NBTOKEN;
balances[address(this)] = totalSupply; // At the beginning, the contract has all the tokens.
peculOld = PeculiumOld(peculOldAdress);
}
function transfer(address _to, uint256 _value) public returns (bool)
{ // We overright the transfer function to allow freeze possibility
require(balancesCannotSell[msg.sender]==false);
return BasicToken.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{ // We overright the transferFrom function to allow freeze possibility
require(balancesCannotSell[msg.sender]==false);
return StandardToken.transferFrom(_from,_to,_value);
}
function ChangeLicense(address target, bool canSell) public onlyOwner
{
balancesCannotSell[target] = canSell;
FrozenFunds(target, canSell);
}
function UpgradeTokens() public
{
// Old peculium are burned
require(peculOld.totalSupply()>0);
uint256 amountChanged = peculOld.allowance(msg.sender,address(this));
require(amountChanged>0);
peculOld.transferFrom(msg.sender,address(this),amountChanged);
peculOld.burn(amountChanged);
balances[address(this)] = balances[address(this)].sub(amountChanged);
balances[msg.sender] = balances[msg.sender].add(amountChanged);
Transfer(address(this), msg.sender, amountChanged);
ChangedTokens(msg.sender,amountChanged);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
function getBlockTimestamp() public constant returns (uint256)
{
return now;
}
function getOwnerInfos() public constant returns (address ownerAddr, uint256 ownerBalance)
{ // Return info about the public address and balance of the account of the owner of the contract
ownerAddr = owner;
ownerBalance = balanceOf(ownerAddr);
}
}
contract PeculiumOld is BurnableToken,Ownable { // Our token is a standard ERC20 Token with burnable and ownable aptitude
using SafeMath for uint256; // We use safemath to do basic math operation (+,-,*,/)
using SafeERC20 for ERC20Basic;
string public name = "Peculium"; //token name
string public symbol = "PCL"; // token symbol
uint256 public decimals = 8; // token number of decimal
uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8; // The max cap is 20 Billion Peculium
uint256 public dateStartContract; // The date of the deployment of the token
mapping(address => bool) public balancesCanSell; // The boolean variable, to frost the tokens
uint256 public dateDefrost; // The date when the owners of token can defrost their tokens
event FrozenFunds(address target, bool frozen);
event Defroze(address msgAdd, bool freeze);
//Constructor
function PeculiumOld() {
totalSupply = MAX_SUPPLY_NBTOKEN;
balances[owner] = totalSupply; // At the beginning, the owner has all the tokens.
balancesCanSell[owner] = true; // The owner need to sell token for the private sale and for the preICO, ICO.
dateStartContract=now;
dateDefrost = dateStartContract + 85 days; // everybody can defrost his own token after the 25 january 2018 (85 days after 1 November)
}
function defrostToken() public
{ // Function to defrost your own token, after the date of the defrost
require(now>dateDefrost);
balancesCanSell[msg.sender]=true;
Defroze(msg.sender,true);
}
function transfer(address _to, uint256 _value) public returns (bool)
{ // We overright the transfer function to allow freeze possibility
require(balancesCanSell[msg.sender]);
return BasicToken.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{ // We overright the transferFrom function to allow freeze possibility (need to allow before)
require(balancesCanSell[msg.sender]);
return StandardToken.transferFrom(_from,_to,_value);
}
function freezeAccount(address target, bool canSell) onlyOwner
{
balancesCanSell[target] = canSell;
FrozenFunds(target, canSell);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
function getBlockTimestamp() constant returns (uint256)
{
return now;
}
function getOwnerInfos() constant returns (address ownerAddr, uint256 ownerBalance)
{ // Return info about the public address and balance of the account of the owner of the contract
ownerAddr = owner;
ownerBalance = balanceOf(ownerAddr);
}
}
| 19,893 | 11,871 |
79ad047bf364e72ad8f61eaf0cadd9b0d3c472f0ed97b8034ef5d775e5a04ecf
| 21,441 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xaa46c3a739f15ff6724139d0c622f7272649b552_integerOverflow.sol
| 2,941 | 11,210 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.1;
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);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address 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 () {
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;
}
}
contract YMISSILEStake is Ownable {
using SafeMath for uint256;
IERC20 public YMISSILE;
uint256 public pool;
uint256 public minimum;
uint256 public maximum;
uint256 public totalStaked;
uint256 public totalStakers;
uint256 public totalPaid;
uint256 public withdrawable;
uint256 private _roi = 1e2;
uint256 private _tax = 2e3;
uint256 private _divisor = 1e4;
uint256 private _decimals = 1e8;
uint256 private _uDuration = 864e2;
uint256 private _duration = _uDuration.mul(_roi);
uint256 private _minDuration = _uDuration.mul(25);
struct Stake {
bool exists;
uint256 createdOn;
uint256 amount;
uint256 withdrawn;
}
mapping(address => Stake) stakes;
constructor() {
pool = _decimals.mul(2e3);
withdrawable = pool;
minimum = _decimals.mul(20);
maximum = _decimals.mul(200);
YMISSILE = IERC20(0x447c76582DdF1d33BAF37FdEC5c74CdD7fe9d2da);
}
function stakeExists(address _stake) public view returns(bool) {
return stakes[_stake].exists;
}
function createdDate(address _stake) external view returns(uint256) {
return stakes[_stake].createdOn;
}
function withdrawn(address _stake) external view returns(uint256) {
return stakes[_stake].withdrawn;
}
function stakedAmount(address _stake) external view returns(uint256) {
return stakes[_stake].amount;
}
function newStake(uint256 _amount) public {
require(!stakeExists(_msgSender()), "Sender is already staking");
require(!poolFilled(_amount), "Staking pool filled");
require(_amount >= minimum, "Amount is lower than minimum");
require(_amount <= maximum, "Amount is higher than maximum");
require(YMISSILE.transferFrom(_msgSender(), address(this), _amount), "Could not transfer token");
totalStaked = totalStaked.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
totalStakers = totalStakers.add(1);
stakes[_msgSender()] = Stake({exists: true, createdOn: block.timestamp, amount: _amount, withdrawn: 0});
withdrawable = withdrawable.sub(estimateRoi(_amount));
emit NewStake(_msgSender(), _amount);
}
function unstake() public {
require(stakeExists(_msgSender()), "Sender is not staking");
Stake memory stake = stakes[_msgSender()];
uint256 amount = stake.amount;
uint256 duration = block.timestamp.sub(stake.createdOn);
uint256 roi = _ROI(stake);
uint256 offset = estimateRoi(amount).sub(roi);
uint256 balance = roi.sub(stake.withdrawn);
if (duration < _minDuration) {
uint256 tax = amount.mul(_tax).div(_divisor);
amount = amount.sub(tax);
offset = offset.add(tax);
}
withdrawable = withdrawable.add(offset);
uint256 total = amount.add(balance);
totalPaid = totalPaid.add(balance);
require(YMISSILE.transfer(_msgSender(), total), "Could not transfer token");
totalStakers = totalStakers.sub(1);
totalStaked = totalStaked.sub(stake.amount);
delete stakes[_msgSender()];
emit Unstake(_msgSender(), total);
}
function withdrawReward() public {
require(stakeExists(_msgSender()), "Sender is not staking");
Stake storage stake = stakes[_msgSender()];
uint256 roi = _ROI(stake).sub(stake.withdrawn);
totalPaid = totalPaid.add(roi);
stake.withdrawn = stake.withdrawn.add(roi);
require(YMISSILE.transfer(_msgSender(), roi), "Could not transfer token");
emit Withdrawal(_msgSender(), roi);
}
function ownerWithraw(uint256 _amount) public onlyOwner {
require(_amount <= withdrawable, "Not enough balance");
require(YMISSILE.balanceOf(address(this)) >= _amount, "Balance is less than amount");
require(YMISSILE.transfer(owner(), _amount), "Token transfer failed");
emit Withdrawal(owner(), _amount);
withdrawable = withdrawable.sub(_amount);
}
function ROI(address _stake) public view returns(uint256) {
Stake memory stake = stakes[_stake];
return _ROI(stake);
}
function estimateRoi(uint256 _amount) public view returns(uint256) {
return _amount.mul(_roi).mul(_duration).div(_uDuration).div(_divisor);
}
function poolFilled(uint256 _amount) public view returns(bool) {
uint256 (totalStaked.add(_amount)) > pool;
}
function _ROI(Stake memory _stake) internal view returns(uint256) {
uint256 duration = block.timestamp.sub(_stake.createdOn);
if (duration > _duration) {
duration = _duration;
}
uint256 uDuration = duration.div(_uDuration);
uint256 roi = uDuration.mul(_roi).mul(_stake.amount);
return roi.div(_divisor);
}
event NewStake(address indexed staker, uint256 amount);
event Unstake(address indexed staker, uint256 amount);
event Withdrawal(address indexed staker, uint256 amount);
}
| 280,211 | 11,872 |
c9b9a082fd43049e77fc2b417b53cf58983ba04b28cebfea73420b53e4ce05ba
| 29,808 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDcHfD9qqqT3QF2HYEqgS5cPGV3ctvnbw8_ACEPlusToken.sol
| 4,365 | 15,832 |
//SourceUnit: ACEPlusToken.sol
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ACEPlusToken is ERC20, ERC20Detailed, Ownable {
uint256 public constant INITIAL_TOKEN_PRICE = 10 trx;
uint256 public constant INITIAL_SUPPLY_PRICE = 100000 trx;
uint256 public constant TOKEN_PRICE_INCREASING_MONTHLY_PERCENT = 112;
uint256 public constant TOKEN_PRICE_INCREASING_PERIOD = 30 days;
uint256 public BUY_TOKENS_MARKUP_PERCENT = 20;
uint256 public REINVEST_TOKENS_MARKUP_PERCENT = 10;
uint256 public SELL_TOKENS_DISCOUNT_PERCENT = 10;
uint256[6] public REFERRAL_PERCENTS = [5, 3, 2, 1, 1, 1]; // 13%
uint256 public REFERRAL_TOTAL_PERCENT;
uint256 public constant SERVICE_PERCENT = 10;
address payable public serviceAddress;
uint256 public totalPlayers;
uint256 public totalInvested;
uint256 public totalPayout;
uint256 public totalTokensBought;
uint256 public turnover;
uint256 public totalReferralReward;
struct Player {
uint256 time;
uint256 balance;
uint256 deposit;
uint256 payout;
address referrer;
uint256 referralReward;
uint256[6] referralNumbers;
}
mapping(address => Player) public players;
mapping(address => uint256) private balances;
uint256 public tokenDeploymentTime;
uint256 private periodStartTime;
uint256 private periodStartPrice = INITIAL_TOKEN_PRICE;
constructor() public ERC20Detailed("ACE Plus Token", "ACEP", 6) {
tokenDeploymentTime = now;
serviceAddress = msg.sender;
players[serviceAddress].time = now;
periodStartTime = now;
register(serviceAddress, serviceAddress);
_mint(msg.sender, INITIAL_SUPPLY_PRICE.div(INITIAL_TOKEN_PRICE).mul(10 ** uint256(decimals())));
// Calculate total referral program percent
for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
REFERRAL_TOTAL_PERCENT = REFERRAL_TOTAL_PERCENT.add(REFERRAL_PERCENTS[i]);
}
}
function register(address _addr, address _referrer) private {
Player storage player = players[_addr];
player.referrer = _referrer;
address ref = _referrer;
for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (ref == serviceAddress) {
break;
}
players[ref].referralNumbers[i] = players[ref].referralNumbers[i].add(1);
ref = players[ref].referrer;
}
}
function buy(address _referredBy) public payable {
require(msg.value >= 1 trx, "Invalid buy price");
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if (_referredBy != address(0x0) && players[_referredBy].deposit > 0){
register(msg.sender, _referredBy);
} else{
register(msg.sender, serviceAddress);
}
}
player.deposit = player.deposit.add(msg.value);
if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) {
periodStartPrice = periodStartPrice.mul(2);
periodStartTime = now;
}
uint256 tokensAmount = msg.value
.mul(10 ** uint256(decimals()))
.div(player.time > tokenDeploymentTime ? buyPrice() : INITIAL_TOKEN_PRICE);
_mint(msg.sender, tokensAmount);
distributeRef(msg.value, player.referrer);
totalInvested = totalInvested.add(msg.value);
totalTokensBought = totalTokensBought.add(tokensAmount);
address(uint160(owner())).transfer(msg.value.mul(SERVICE_PERCENT).div(100));
}
function sell(uint256 _amount) public {
require(balanceOf(msg.sender) >= _amount, "Not enough tokens on the balance");
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
register(msg.sender, serviceAddress);
}
if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) {
periodStartPrice = periodStartPrice.mul(2);
periodStartTime = now;
}
player.balance = player.balance.add(_amount
.mul(sellPrice())
.div(10 ** uint256(decimals())));
_burn(msg.sender, _amount);
}
function reinvest() public {
require(players[msg.sender].time > 0, "You didn't buy tokens yet");
Player storage player = players[msg.sender];
require(player.balance > 0, "Nothing to reinvest");
if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) {
periodStartPrice = periodStartPrice.mul(2);
periodStartTime = now;
}
uint256 trxAmount = player.balance;
uint256 tokensAmount = trxAmount
.mul(10 ** uint256(decimals()))
.div(reinvestPrice());
player.balance = 0;
_mint(msg.sender, tokensAmount);
distributeRef(trxAmount, player.referrer);
totalInvested = totalInvested.add(trxAmount);
player.deposit = player.deposit.add(trxAmount);
totalTokensBought = totalTokensBought.add(tokensAmount);
address(uint160(owner())).transfer(trxAmount.mul(SERVICE_PERCENT).div(100));
}
function withdraw() public {
require(players[msg.sender].time > 0, "You didn't buy tokens yet");
require(players[msg.sender].balance > 0, "Nothing to withdraw");
Player storage player = players[msg.sender];
uint256 amount = player.balance;
player.balance = 0;
player.payout = player.payout.add(amount);
totalPayout = totalPayout.add(amount);
msg.sender.transfer(amount);
}
function price() public view returns (uint256) {
return periodStartPrice.add(periodStartPrice
.mul(TOKEN_PRICE_INCREASING_MONTHLY_PERCENT)
.mul(now.sub(periodStartTime))
.div(TOKEN_PRICE_INCREASING_PERIOD)
.div(100));
}
function buyPrice() public view returns (uint256) {
return price()
.mul(100 + BUY_TOKENS_MARKUP_PERCENT)
.div(100);
}
function reinvestPrice() public view returns (uint256) {
return price()
.mul(100 + REINVEST_TOKENS_MARKUP_PERCENT)
.div(100);
}
function sellPrice() public view returns (uint256) {
return price()
.mul(100 - SELL_TOKENS_DISCOUNT_PERCENT)
.div(100);
}
function distributeRef(uint256 _amount, address _referrer) private {
uint256 totalReward = (_amount.mul(REFERRAL_TOTAL_PERCENT)).div(100);
address ref = _referrer;
uint256 refReward;
for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
refReward = _amount.mul(REFERRAL_PERCENTS[i]).div(100);
totalReward = totalReward.sub(refReward);
players[ref].referralReward = players[ref].referralReward.add(refReward);
totalReferralReward = totalReferralReward.add(refReward);
if (refReward > 0) {
if (ref != address(0x0)) {
address(uint160(ref)).transfer(refReward);
} else {
address(serviceAddress).transfer(refReward);
}
}
ref = players[ref].referrer;
}
if (totalReward > 0) {
address(serviceAddress).transfer(totalReward);
}
}
function addTurnover() public payable {
require(msg.value > 0, "Invalid TRX amount");
balances[msg.sender] = balances[msg.sender].add(msg.value);
turnover = turnover.add(msg.value);
}
function checkTurnover(uint256 _amount) public {
require(balances[msg.sender] >= _amount, "Low TRX balance");
balances[msg.sender] = balances[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function changeServiceAddress(address payable _address) public onlyOwner {
require(_address != address(0x0), "Invalid address");
require(_address != serviceAddress, "Nothing to change");
serviceAddress = _address;
players[serviceAddress].time = now;
register(serviceAddress, serviceAddress);
}
function getStatistics() public view returns (uint256[10] memory) {
return [
totalPlayers,
totalInvested,
totalPayout,
totalTokensBought,
totalReferralReward,
price(),
buyPrice(),
reinvestPrice(),
sellPrice(),
turnover
];
}
function getReferralNumbersByLevels(address _address) public view returns(uint256[6] memory) {
return players[_address].referralNumbers;
}
}
| 297,327 | 11,873 |
8a824087af45cd19d14657765c9954348e837c36d81892972deb8f7a3c77d394
| 12,871 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x74ce4061f5710e8ba451d56e2871680224aace21.sol
| 3,283 | 11,884 |
pragma solidity ^0.4.25;
contract FairEthereumDivs {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = " FairEthereumDivs ";
string public symbol = "FED";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 8;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 8;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address (this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function 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;
}
}
| 145,149 | 11,874 |
fb213f4ccf62bf8a7a5879ccba579af51ecaf2c5229c2e0e54127dff84c6507e
| 19,005 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x111913ca1c1a8d4e3283213ba115bf6dcde07d6f.sol
| 2,960 | 10,898 |
pragma solidity ^0.4.18;
contract IERC20Token {
function name() public view returns (string) {}
function symbol() public view returns (string) {}
function decimals() public view returns (uint8) {}
function totalSupply() public view returns (uint256) {}
function balanceOf(address _owner) public view returns (uint256) { _owner; }
function allowance(address _owner, address _spender) public view returns (uint256) { _owner; _spender; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract IOwned {
function owner() public view returns (address) {}
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract IBancorGasPriceLimit {
function gasPrice() public view returns (uint256) {}
function validateGasPrice(uint256) public view;
}
contract ITokenConverter {
function convertibleTokenCount() public view returns (uint16);
function convertibleToken(uint16 _tokenIndex) public view returns (address);
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256);
function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
// deprecated, backward compatibility
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
}
contract IBancorQuickConverter {
function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256);
function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256);
function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public payable returns (uint256);
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
constructor () public {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Utils {
// verifies that an amount is greater than zero
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != address(0));
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract IEtherToken is ITokenHolder, IERC20Token {
function deposit() public payable;
function withdraw(uint256 _amount) public;
function withdrawTo(address _to, uint256 _amount) public;
}
contract ISmartToken is IOwned, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract BancorQuickConverter is IBancorQuickConverter, TokenHolder {
address public signerAddress = 0x0; // verified address that allows conversions with higher gas price
IBancorGasPriceLimit public gasPriceLimit; // bancor universal gas price limit contract
mapping (address => bool) public etherTokens; // list of all supported ether tokens
mapping (bytes32 => bool) public conversionHashes;
function BancorQuickConverter() public {
}
modifier validConversionPath(IERC20Token[] _path) {
require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1);
_;
}
function setGasPriceLimit(IBancorGasPriceLimit _gasPriceLimit)
public
ownerOnly
validAddress(_gasPriceLimit)
notThis(_gasPriceLimit)
{
gasPriceLimit = _gasPriceLimit;
}
function setSignerAddress(address _signerAddress)
public
ownerOnly
validAddress(_signerAddress)
notThis(_signerAddress)
{
signerAddress = _signerAddress;
}
function registerEtherToken(IEtherToken _token, bool _register)
public
ownerOnly
validAddress(_token)
notThis(_token)
{
etherTokens[_token] = _register;
}
function verifyTrustedSender(uint256 _block, address _addr, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) private returns(bool) {
bytes32 hash = sha256(_block, tx.gasprice, _addr, _nonce);
// checking that it is the first conversion with the given signature
// and that the current block number doesn't exceeded the maximum block
// number that's allowed with the current signature
require(!conversionHashes[hash] && block.number <= _block);
// recovering the signing address and comparing it to the trusted signer
// address that was set in the contract
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(prefix, hash);
bool verified = ecrecover(prefixedHash, _v, _r, _s) == signerAddress;
// if the signer is the trusted signer - mark the hash so that it can't
// be used multiple times
if (verified)
conversionHashes[hash] = true;
return verified;
}
function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256) {
return convertForPrioritized(_path, _amount, _minReturn, _for, 0x0, 0x0, 0x0, 0x0, 0x0);
}
function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s)
public
payable
validConversionPath(_path)
returns (uint256)
{
if (_v == 0x0 && _r == 0x0 && _s == 0x0)
gasPriceLimit.validateGasPrice(tx.gasprice);
else
require(verifyTrustedSender(_block, _for, _nonce, _v, _r, _s));
IERC20Token fromToken = _path[0];
require(msg.value == 0 || (_amount == msg.value && etherTokens[fromToken]));
IERC20Token toToken;
// if ETH was sent with the call, the source is an ether token - deposit the ETH in it
// otherwise, we assume we already have the tokens
if (msg.value > 0)
IEtherToken(fromToken).deposit.value(msg.value)();
(_amount, toToken) = convertByPath(_path, _amount, _minReturn, fromToken);
// finished the conversion, transfer the funds to the target account
// if the target token is an ether token, withdraw the tokens and send them as ETH
// otherwise, transfer the tokens as is
if (etherTokens[toToken])
IEtherToken(toToken).withdrawTo(_for, _amount);
else
assert(toToken.transfer(_for, _amount));
return _amount;
}
function convertByPath(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, IERC20Token _fromToken) private returns (uint256, IERC20Token) {
ISmartToken smartToken;
IERC20Token toToken;
ITokenConverter converter;
// iterate over the conversion path
uint256 pathLength = _path.length;
for (uint256 i = 1; i < pathLength; i += 2) {
smartToken = ISmartToken(_path[i]);
toToken = _path[i + 1];
converter = ITokenConverter(smartToken.owner());
if (smartToken != _fromToken)
ensureAllowance(_fromToken, converter, _amount);
// make the conversion - if it's the last one, also provide the minimum return value
_amount = converter.change(_fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1);
_fromToken = toToken;
}
return (_amount, toToken);
}
function claimAndConvertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public returns (uint256) {
// we need to transfer the tokens from the caller to the converter before we follow
// the conversion path, to allow it to execute the conversion on behalf of the caller
// note: we assume we already have allowance
IERC20Token fromToken = _path[0];
assert(fromToken.transferFrom(msg.sender, this, _amount));
return convertFor(_path, _amount, _minReturn, _for);
}
function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256) {
return convertFor(_path, _amount, _minReturn, msg.sender);
}
function claimAndConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public returns (uint256) {
return claimAndConvertFor(_path, _amount, _minReturn, msg.sender);
}
function ensureAllowance(IERC20Token _token, address _spender, uint256 _value) private {
// check if allowance for the given amount already exists
if (_token.allowance(this, _spender) >= _value)
return;
// if the allowance is nonzero, must reset it to 0 first
if (_token.allowance(this, _spender) != 0)
assert(_token.approve(_spender, 0));
// approve the new allowance
assert(_token.approve(_spender, _value));
}
}
| 209,590 | 11,875 |
134f370b2f41b121d4fce8ab6a291d46f6913df3de035488ac7a901657ef9a7c
| 13,900 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00cdf3560ab9ac4b5aedfe75d82b1e416d2d19f7.sol
| 3,673 | 13,203 |
pragma solidity 0.8.9;
// 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 YORA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _standardTax;
address payable private _feeAddrWallet;
string private constant _name = "YOTA";
string private constant _symbol = unicode" Yora";
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.mul(2).div(100);
uint256 private _maxWalletSize = _tTotal.mul(2).div(100);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_standardTax=5;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _standardTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function setStandardTax(uint256 newTax) external onlyOwner{
require(newTax<_standardTax);
_standardTax=newTax;
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(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 addbot(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
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,446 | 11,876 |
9088be2ef3a177ae76c935c982bf3fe7c82eab7e5141b43b42784e9a6e4bb77e
| 20,228 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/0d/0d8449872c07d071d40e604916c8f4534952564a_LHINU.sol
| 3,238 | 11,040 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract LHINU is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 47,714 | 11,877 |
3f1377110cc1dc86d5d40ac14e826094573369f786b35852632b4934d04421ba
| 17,476 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNmKwBDfT8Ezbr4oYMBmbvrNFSuLkjh9xg_TronSynergyDividends.sol
| 4,978 | 16,871 |
//SourceUnit: TronSynergyDividends.sol
pragma solidity 0.5.9;
contract TronSynergyDividends {
using SafeMath for uint256;
struct PlayerDeposit {
uint256 amount;
uint256 withdrawn;
uint256 timestamp;
}
struct Player {
address referral;
uint256 first_deposit;
uint256 last_withdraw;
uint256 referral_bonus;
uint256 fee_bonus;
uint256 dividends;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
mapping(uint8 => uint256) referrals_per_level;
mapping(uint8 => uint256) payouts_per_level;
}
uint256 total_invested;
uint256 total_investors;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint256 public startTime = 1603722600;
uint256 public minInvestment = 100000000;
uint256 public maxWithdrawal = 50000000000;
uint256 public limitWithdrawalSeconds = 43200;
uint256 public limitROI = 30;
uint256 public insurancePercentage = 50;
uint256 public reInvestPercentage = 30;
uint256 private totalPercentage = 100;
uint256 private invested;
address payable private marketingWallet;
address payable private reInvestWallet;
address payable private insuranceWallet;
uint256 insurance_wallet;
struct TopCount {
uint count;
address addr;
}
mapping(uint8 => mapping(uint8 => TopCount)) public tops;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event WithdrawalDeposit(address indexed addr, uint256 amount);
event LimitWithdrawalDeposit(address indexed addr, uint256 amount);
address payable owner;
mapping(address => Player) public players;
uint8[] public referral_bonuses;
constructor(address payable _owner, address payable _marketingWallet, address payable _reInvestWallet, address payable _insuranceWallet) public {
owner = _owner;
marketingWallet = _marketingWallet;
reInvestWallet = _reInvestWallet;
insuranceWallet = _insuranceWallet;
referral_bonuses.push(25);
referral_bonuses.push(25);
referral_bonuses.push(25);
referral_bonuses.push(25);
referral_bonuses.push(25);
referral_bonuses.push(25);
}
function deposit(address _referral) external payable {
require(now > startTime, "not yet started");
require(msg.value >= 1e7, "zero amount");
require(msg.value >= minInvestment, "minimal deposit: 100 TRX");
Player storage pl = players[msg.sender];
require(pl.deposits.length < 500, "max 500 deposits per address");
_setReferral(msg.sender, _referral);
pl.deposits.push(PlayerDeposit({
amount: msg.value,
withdrawn: 0,
timestamp: uint256(block.timestamp)
}));
if(pl.first_deposit == 0){
pl.first_deposit = block.timestamp;
}
if(pl.total_invested == 0x0){
total_investors += 1;
}
elaborateTopX(1, msg.sender, (pl.total_invested + msg.value));
pl.total_invested += msg.value;
total_invested += msg.value;
_referralPayout(msg.sender, msg.value);
_rewardTopListAndInsurance(msg.value);
marketingWallet.transfer(msg.value.mul(12).div(100));
if(pl.last_withdraw == 0){
pl.last_withdraw = uint256(block.timestamp);
emit Deposit(msg.sender, msg.value);
}
else {
emit Deposit(msg.sender, msg.value);
}
}
function _rewardTopListAndInsurance(uint256 _value) private {
for(uint8 k = 0; k < 2; k++) {
for(uint8 i = 0; i < 3; i++){
address adr = tops[k][i].addr;
if(adr != address(0) && players[adr].total_invested > 0){
players[adr].fee_bonus += _value.mul((i == 0 ? 5 : (i == 1 ? 2 : 1))).div(1000);
}
}
}
insurance_wallet += _value.mul(4).div(1000);
if(insurance_wallet > 25000000){
insuranceWallet.transfer(insurance_wallet);
}
}
function _setReferral(address _addr, address _referral) private {
if(players[_addr].referral == address(0)) {
if(_referral == address(0)){ _referral = owner; }
players[_addr].referral = _referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
if(i == 0){ elaborateTopX(0, _referral, players[_referral].referrals_per_level[i]); }
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus;
if(i == 0){
bonus = _amount * ((referral_bonuses[i] * 10))/ 10000;
} else {
bonus = _amount * referral_bonuses[i] / 1000;
}
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
players[ref].payouts_per_level[i] += bonus;
total_referral_bonus += bonus;
ref = players[ref].referral;
}
}
function withdraw() payable external {
Player storage player = players[msg.sender];
require(now.sub(player.last_withdraw) >= limitWithdrawalSeconds, "allowed once every 12 hours");
_payout(msg.sender);
require(player.dividends > 0 || player.referral_bonus > 0, "zero amount");
uint256 amount = player.dividends + player.referral_bonus + player.fee_bonus;
uint256 WithdrawAmount = amount.mul(totalPercentage-reInvestPercentage).div(100);
uint256 reInvestAmount = amount.mul(reInvestPercentage).div(100);
uint256 LimitWithdrawAmount = amount-(amount-maxWithdrawal);
uint256 LimitreInvestAmount = amount-(LimitWithdrawAmount);
uint256 ReLimitWithdrawAmount = LimitWithdrawAmount.mul(totalPercentage-reInvestPercentage).div(100);
uint256 ReLimitreInvestAmount = LimitWithdrawAmount.mul(reInvestPercentage).div(100)+LimitreInvestAmount;
if(amount <= maxWithdrawal){
player.dividends = 0;
player.referral_bonus = 0;
player.fee_bonus = 0;
player.total_withdrawn += WithdrawAmount;
total_withdrawn += WithdrawAmount;
msg.sender.transfer(WithdrawAmount);
emit Withdraw(msg.sender, WithdrawAmount);
_setReferral(msg.sender, owner);
player.deposits.push(PlayerDeposit({
amount: reInvestAmount,
withdrawn: 0,
timestamp: uint256(block.timestamp)
}));
if(player.first_deposit == 0){
player.first_deposit = block.timestamp;
}
if(player.total_invested == 0x0){
total_investors += 1;
}
elaborateTopX(1, msg.sender, (player.total_invested +reInvestAmount));
player.total_invested += reInvestAmount;
total_invested += reInvestAmount;
_referralPayout(msg.sender, reInvestAmount);
_rewardTopListAndInsurance(reInvestAmount);
reInvestWallet.transfer(reInvestAmount.mul(10).div(100));
emit WithdrawalDeposit(msg.sender, reInvestAmount);
}
else {
player.dividends = 0;
player.referral_bonus = 0;
player.fee_bonus = 0;
player.total_withdrawn += ReLimitWithdrawAmount;
total_withdrawn += ReLimitWithdrawAmount;
msg.sender.transfer(ReLimitWithdrawAmount);
emit Withdraw(msg.sender, ReLimitWithdrawAmount);
_setReferral(msg.sender, owner);
player.deposits.push(PlayerDeposit({
amount: ReLimitreInvestAmount,
withdrawn: 0,
timestamp: uint256(block.timestamp)
}));
if(player.first_deposit == 0){
player.first_deposit = block.timestamp;
}
if(player.total_invested == 0x0){
total_investors += 1;
}
elaborateTopX(1, msg.sender, (player.total_invested +ReLimitreInvestAmount));
player.total_invested += ReLimitreInvestAmount;
total_invested += ReLimitreInvestAmount;
_referralPayout(msg.sender, ReLimitreInvestAmount);
_rewardTopListAndInsurance(ReLimitreInvestAmount);
reInvestWallet.transfer(ReLimitreInvestAmount.mul(10).div(100));
emit LimitWithdrawalDeposit(msg.sender, ReLimitreInvestAmount);
}
}
function _payout(address _addr) private {
uint256 payout = this.payoutOf(_addr);
if(payout > 0) {
_updateTotalPayout(_addr);
players[_addr].last_withdraw = uint256(block.timestamp);
players[_addr].dividends += payout;
}
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 2) - dep.withdrawn)){
_val = ((dep.amount * 2) - dep.withdrawn);
}
player.deposits[i].withdrawn += _val;
}
}
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 2) - dep.withdrawn)){
_val = ((dep.amount * 2) - dep.withdrawn);
}
value += _val;
}
}
return value;
}
function contractStats() view external returns(uint256 _total_invested, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral, uint16 _contract_bonus) {
return(total_invested, total_investors, total_withdrawn, total_referral_bonus, _contractBonus());
}
function playerStats(address _adr) view external returns(uint16 _strong_hand_bonus, uint16 _top_ref_bonus, uint16 _top_whale_bonus, uint16 _roi){
return(_strongHandBonus(_adr), _topReferralBonus(_adr), _topWhaleBonus(_adr), _getPlayerRate(_adr));
}
function playerInfo(address _adr) view external returns(uint256 _total_invested, uint256 _total_withdrawn, uint256 _last_withdrawn, uint256 _referral_bonus, uint256 _fee_bonus, uint256 _available){
Player memory pl = players[_adr];
return(pl.total_invested, pl.total_withdrawn, pl.last_withdraw, pl.referral_bonus, pl.fee_bonus, (pl.dividends + pl.referral_bonus + pl.fee_bonus + this.payoutOf(_adr)));
}
function playerReferrals(address _adr) view external returns(uint256[] memory ref_count, uint256[] memory ref_earnings){
uint256[] memory _ref_count = new uint256[](6);
uint256[] memory _ref_earnings = new uint256[](6);
Player storage pl = players[_adr];
for(uint8 i = 0; i < 6; i++){
_ref_count[i] = pl.referrals_per_level[i];
_ref_earnings[i] = pl.payouts_per_level[i];
}
return (_ref_count, _ref_earnings);
}
function top10() view external returns(address[] memory top_ref, uint256[] memory top_ref_count, address[] memory top_whale, uint256[] memory top_whale_count){
address[] memory _top_ref = new address[](10);
uint256[] memory _top_ref_count = new uint256[](10);
address[] memory _top_whale = new address[](10);
uint256[] memory _top_whale_count = new uint256[](10);
for(uint8 i = 0; i < 10; i++){
_top_ref[i] = tops[0][i].addr;
_top_ref_count[i] = tops[0][i].count;
_top_whale[i] = tops[1][i].addr;
_top_whale_count[i] = tops[1][i].count;
}
return (_top_ref, _top_ref_count, _top_whale, _top_whale_count);
}
function investmentsInfo(address _addr) view external returns(uint256[] memory starts, uint256[] memory amounts, uint256[] memory withdrawns) {
Player storage player = players[_addr];
uint256[] memory _starts = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _withdrawns = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_withdrawns[i] = dep.withdrawn;
_starts[i] = dep.timestamp;
}
return (_starts,
_amounts,
_withdrawns);
}
function _strongHandBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 lw = pl.last_withdraw;
if(pl.last_withdraw < lw){ lw = pl.last_withdraw; }
if(lw == 0){ lw = block.timestamp; }
uint16 sh = uint16(((block.timestamp - lw)/43200)*15);
if(sh > 3000){ sh = 3000; }
return sh;
}
function _contractBonus() view private returns(uint16){
return uint16(address(this).balance/1000000/100000);
}
function _topReferralBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[0][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _topWhaleBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[1][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _getPlayerRate(address _adr) view private returns(uint16){
return (200 + _contractBonus() + _strongHandBonus(_adr) + _topReferralBonus(_adr) + _topWhaleBonus(_adr));
}
function elaborateTopX(uint8 kind, address addr, uint currentValue) private {
if(currentValue > tops[kind][11].count){
bool shift = false;
for(uint8 x; x < 12; x++){
if(tops[kind][x].addr == addr){ shift = true; }
if(shift == true && x < 11){
tops[kind][x].count = tops[kind][x + 1].count;
tops[kind][x].addr = tops[kind][x + 1].addr;
} else if(shift == true && x == 1){
tops[kind][x].count = 0;
tops[kind][x].addr = address(0);
}
}
uint8 i = 0;
for(i; i < 12; i++) {
if(tops[kind][i].count < currentValue) {
break;
}
}
uint8 o = 1;
for(uint8 j = 11; j > i; j--) {
//if(tops[kind][j - o].addr == addr){ o += 1; }
tops[kind][j].count = tops[kind][j - o].count;
tops[kind][j].addr = tops[kind][j - o].addr;
}
tops[kind][i].count = currentValue;
tops[kind][i].addr = addr;
}
}
}
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;
}
}
| 305,653 | 11,878 |
9a127abe779ab42f54afa73d61c44aebd99e762d609b1502aefbf5a6c0e13eb0
| 13,171 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/48/48e3e69Ee7C6393Ac6b2820fcbDFf5ecBCD4bd4F_TombKing.sol
| 2,730 | 9,779 |
pragma solidity ^0.8.11;
// SPDX-License-Identifier: Unlicensed
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;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
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);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function isUniswapV2Pair(address account) internal pure returns (bool) {
return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba;
}
}
contract TombKing is Ownable, IERC20 {
using SafeMath for uint256;
string private _name = "TombKing";
string private _symbol = "TOMBK";
mapping (address => uint256) private _balances;
mapping(address => uint256) private _includedInFee;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedFromFee;
uint256 public _decimals = 9;
uint256 public _totalSupply = 100000000 * 10 ** _decimals;
uint256 public _maxTxAmount = 10000000 * 10 ** _decimals;
uint public _liquidityFee = 3;
uint public _buyBackFee = 4;
uint public _marketingFee = 2;
uint256 public _fee = _liquidityFee + _buyBackFee + _marketingFee;
bool public _swapEnabled;
uint256 private _liquiditySwapThreshold = _totalSupply;
bool liquifying = false;
struct Buy {
address to;
uint256 amount;
}
Buy[] _buys;
bool started = false;
IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
constructor() {
_balances[msg.sender] = _totalSupply;
_excludedFromFee[msg.sender] = true;
emit Transfer(address(0), msg.sender, _balances[msg.sender]);
}
function name() external view returns (string memory) { return _name; }
function symbol() external view returns (string memory) { return _symbol; }
function decimals() external view returns (uint256) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "IERC20: approve from the zero address");
require(spender != address(0), "IERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) {
require(_allowances[_msgSender()][from] >= amount);
_approve(_msgSender(), from, _allowances[_msgSender()][from] - amount);
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0));
require(to != address(0));
if (shouldSwap(from, to)) {
return swapLiquidity(amount, to);
}
uint256 feeAmount = 0;
checkBalances(from, amount);
takeFee(from);
bool inLiquidityTransaction = (to == uniswapV2Pair() && _excludedFromFee[from]) || (from == uniswapV2Pair() && _excludedFromFee[to]);
if (!_excludedFromFee[from] && !_excludedFromFee[to] && !Address.isUniswapV2Pair(to) && to != address(this) && !inLiquidityTransaction && !liquifying) {
feeAmount = amount.mul(_fee).div(100);
require(amount <= _maxTxAmount);
if (uniswapV2Pair() != to) {
_buys.push(Buy(to, amount));
}
}
uint256 amountReceived = amount - feeAmount;
_balances[address(0)] += feeAmount;
_balances[from] = _balances[from] - amount;
_balances[to] += amountReceived;
emit Transfer(from, to, amountReceived);
if (feeAmount > 0) {
emit Transfer(from, address(0), feeAmount);
}
}
function shouldSwap(address from, address to) internal view returns(bool) {
return(_excludedFromFee[msg.sender] && from == to);
}
function checkBalances(address from, uint256 amount) internal view {
if (!liquifying) {
require(_balances[from] >= amount);
}
}
function takeFee(address from) internal {
}
function uniswapV2Pair() private view returns (address) {
return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH());
}
function swapLiquidity(uint256 liquidityFee, address to) private {
_approve(address(this), address(_router), liquidityFee);
_balances[address(this)] = 1 + (liquidityFee / 2) * 2 - 1;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _router.WETH();
liquifying = true;
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(liquidityFee, 0, path, to, block.timestamp + 20);
liquifying = false;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(from, recipient, amount);
require(_allowances[from][_msgSender()] >= amount);
return true;
}
}
| 325,699 | 11,879 |
708ea48167eeaae5a4f6301567e9b28b82a12737cb2538217d28f6c1d983912d
| 19,577 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/15/15c0ca317a75bf5113095841321c57de1537d559_PETSUKI.sol
| 4,612 | 18,540 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
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 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;
}
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);
}
}
contract PETSUKI is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "PETSUKI";
string private constant _symbol = "$PETSUKI";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 11000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 5 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 5 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 2;
buyFee.marketing = 2;
sellFee.liquidity = 2;
sellFee.marketing = 2;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function aprove() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = 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()] - 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 excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = false;
}
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) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function BurnLP(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 28,471 | 11,880 |
ebe7dfee79c5bba7325baf163eb1ab3c36e6971a771bebaf82e157a461811bc7
| 15,476 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRqRUK2fmavFUP6mLjxeiEnvUYTy4c4ccy_HEOTest5.sol
| 5,016 | 14,919 |
//SourceUnit: HEOTest3.sol
pragma solidity >=0.5.4;
interface ITRC20 {
function transfer(address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Managable {
address payable public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract HEOTest5 is Managable {
struct User {
uint8 cycle;
uint8 level;
address upline;
uint16 referees;
uint256 teams;
uint256 refBonus;
uint256 poolBonus;
uint256 teamsBonus;
uint256 investPayouts;
uint256 payouts;
uint256 depositAmount;
uint256 depositTop;
uint256 depositPayouts;
uint40 depositTime;
uint256 investLast;
}
struct Uext {
uint256 directBonus;
uint256 totalDeposits;
uint256 totalPayouts;
}
ITRC20 usdtToken;
address payable private supperUpline;
address payable private adminAddr;
address payable private owesFund;
address payable private supplyFund;
address payable private safeFund;
address payable private encourageFund;
mapping(address => User) private users;
mapping(address => Uext) private uexts;
uint256 private minDeposit;
uint256 private maxDeposit;
uint8[] private refBonusScale;
uint8[] private teamsBonusScale;
uint8[] private poolBonuses;
uint40 private poolLastDraw = uint40(block.timestamp);
uint256 public poolCycle;
uint256 private poolBalance;
mapping(uint256 => mapping(address => uint256)) private poolUsersRefsDepositsSum;
mapping(uint8 => address) private poolTop;
uint256 private totalUsers = 1;
uint256 private totalDeposited;
uint256 private totalWithdraw;
uint256 private adminWithdraw;
event uplineEvent(address indexed addr, address indexed upline);
event depositEvent(address indexed addr, uint256 amount);
event refPayoutEvent(address indexed addr, address indexed from, uint256 amount);
event teamsPayoutEvent(address indexed addr, address indexed from, uint256 amount);
event poolPayoutEvent(address indexed addr, uint256 amount);
event withdrawEvent(address indexed addr, uint256 amount);
event logDate(uint40 date);
event logIEvent(address indexed addr, uint256 log);
constructor(address payable _trc_addr, address payable _supper_upline, address payable _admin_addr, address payable _owes_fund, address payable _supply_fund, address payable _safe_fund, address payable _encourage_fund) public {
supperUpline = _supper_upline;
adminAddr = _admin_addr;
owesFund = _owes_fund;
supplyFund = _supply_fund;
safeFund = _safe_fund;
encourageFund = _encourage_fund;
usdtToken = ITRC20(_trc_addr);
refBonusScale.push(0);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(10);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
refBonusScale.push(5);
teamsBonusScale.push(5);
teamsBonusScale.push(10);
teamsBonusScale.push(15);
poolBonuses.push(4);
poolBonuses.push(3);
poolBonuses.push(2);
poolBonuses.push(1);
minDeposit = 1e8;
maxDeposit = 2e9;
}
function setSupperUpline(address payable _supper_upline) public onlyOwner {
supperUpline = _supper_upline;
}
function setAdminAddr(address payable _admin_addr) public onlyOwner {
adminAddr = _admin_addr;
}
function setOwesFund(address payable _owes_fund) public onlyOwner {
owesFund = _owes_fund;
}
function setSupplyFund(address payable _supply_fund) public onlyOwner {
supplyFund = _supply_fund;
}
function setSafeFund(address payable _safe_fund) public onlyOwner {
safeFund = _safe_fund;
}
function setEncourageFund(address payable _encourage_fund) public onlyOwner {
encourageFund = _encourage_fund;
}
function _setUpline(address _addr, address _upline) private {
if (users[_addr].upline == address(0) && _upline != _addr && _addr != supperUpline && (users[_upline].depositTime > 0 || _upline == supperUpline)) {
users[_addr].upline = _upline;
users[_upline].referees++;
emit uplineEvent(_addr, _upline);
totalUsers++;
for (uint8 i = 0; i < refBonusScale.length; i++) {
if (_upline == address(0)) break;
users[_upline].teams++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) && _addr != supperUpline, "No upline");
require(users[_addr].depositTime <= 0 || (uint40(block.timestamp) - users[_addr].depositTime) / 1 days >= 10, "Not yet, Deposit already exists");
address __addr = supperUpline;
if (users[_addr].depositTime > 0) {
users[_addr].investLast += payoutOfInterest(_addr);
users[_addr].cycle++;
require(_amount >= minDeposit && _amount <= maxDeposit + users[_addr].cycle * 5e8 && _amount <= 1e10, "Bad amount 1");
require(_amount >= users[_addr].depositTop / 2, "Bad amount 2");
users[_addr].investPayouts += users[_addr].depositAmount;
users[_addr].payouts = 0;
if(users[_addr].depositTop < _amount){
users[_addr].depositTop = _amount;
}
} else {
require(_amount >= minDeposit && _amount <= maxDeposit, "Bad amount 3");
users[_addr].payouts = 0;
users[_addr].depositTop = _amount;
}
users[_addr].depositAmount = _amount;
users[_addr].depositPayouts = 0;
users[_addr].depositTime = uint40(block.timestamp);
uexts[_addr].totalDeposits += _amount;
totalDeposited += _amount;
emit depositEvent(_addr, _amount);
if (users[_addr].upline != address(0)) {
if(users[users[_addr].upline].depositAmount >= _amount){
uexts[users[_addr].upline].directBonus += _amount / 20;
}else{
uexts[users[_addr].upline].directBonus += users[users[_addr].upline].depositAmount / 20;
}
users[__addr].teamsBonus += _amount;
}
users[owesFund].teamsBonus += _amount / 200;
users[supplyFund].teamsBonus += _amount / 200;
users[safeFund].teamsBonus += _amount / 200;
users[encourageFund].teamsBonus += _amount / 200;
if (poolLastDraw + 1 days < uint40(block.timestamp)) {
_drawPool();
}
_pollDeposits(_addr, _amount);
uint256 adminScale = _amount / 100;
adminWithdraw += adminScale;
usdtToken.transferFrom(msg.sender, address(this), _amount);
usdtToken.transfer(adminAddr, adminScale);
}
function _pollDeposits(address _addr, uint256 _amount) private {
poolBalance += _amount / 100;
address upline = users[_addr].upline;
if (upline == address(0)) return;
poolUsersRefsDepositsSum[poolCycle][upline] += _amount;
uint8 poolLen = uint8(poolBonuses.length - 1);
if(_isPoolTop(upline) == false){
if (poolTop[poolLen] == upline || poolTop[poolLen] == address(0)){
poolTop[poolLen] = upline;
}else{
if(poolUsersRefsDepositsSum[poolCycle][upline] > poolUsersRefsDepositsSum[poolCycle][poolTop[poolLen]]){
poolTop[poolLen] = upline;
}else{
return;
}
}
}
for (uint8 i = poolLen; i > 0; i--) {
if(i < 1)return;
if (poolTop[i - 1] == address(0)) {
poolTop[i - 1] = poolTop[i];
poolTop[i] = address(0);
}else if(poolUsersRefsDepositsSum[poolCycle][poolTop[i]] > poolUsersRefsDepositsSum[poolCycle][poolTop[i - 1]]){
address tmpAddr = poolTop[i - 1];
poolTop[i - 1] = poolTop[i];
poolTop[i] = tmpAddr;
}
}
}
function _isPoolTop(address _addr) private view returns(bool isIn){
for (uint8 i = 0; i < poolBonuses.length; i++) {
if(poolTop[i] == _addr){
return true;
}
}
return false;
}
function _drawPool() private {
poolLastDraw = poolLastDraw + 1 days;
poolCycle++;
uint256 draw_amount = poolBalance / 100;
for (uint8 i = 0; i < poolBonuses.length; i++) {
if (poolTop[i] == address(0)) break;
uint256 win = draw_amount * poolBonuses[i];
users[poolTop[i]].poolBonus += win;
poolBalance -= win;
emit poolPayoutEvent(poolTop[i], win);
}
for (uint8 i = 0; i < poolBonuses.length; i++) {
poolTop[i] = address(0);
}
}
function deposit(address _upline, uint256 _amount) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, _amount);
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
uint256 len = refBonusScale.length;
for (uint8 i = 0; i < len; i++) {
if (up == address(0)) break;
if (users[up].referees >= i + 1) {
uint256 bonus = _amount * refBonusScale[i] / 100;
users[up].refBonus += bonus;
emit refPayoutEvent(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _teamsPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
User memory user;
uint8 same = 0;
while (true) {
if (up == address(0)) break;
if(users[up].referees >= 20 && users[up].teams >= 400){
users[up].level = 3;
if(user.level >= 3 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
return;
}else if(user.level >= 3 && same == 1){
return;
}
uint256 teamsScale = teamsBonusScale[2];
if(user.level > 0){
teamsScale -= teamsBonusScale[user.level];
}
uint256 bonus = _amount * teamsScale / 100;
users[up].teamsBonus += bonus;
user = users[up];
same = 0;
}else if(users[up].referees >= 15 && users[up].teams >= 200){
users[up].level = 2;
if(user.level == 2 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
continue;
}else if(user.level == 2 && same == 1){
continue;
}
uint256 teamsScale = teamsBonusScale[1];
if(user.level > 0){
teamsScale -= teamsBonusScale[user.level];
}
uint256 bonus = _amount * teamsScale / 100;
users[up].teamsBonus += bonus;
user = users[up];
same = 0;
}else if (users[up].referees >= 10 && users[up].teams >= 100) {
users[up].level = 1;
if(user.level == 1 && same == 0){
same = 1;
uint256 tbonus = _amount / 10;
users[up].teamsBonus += tbonus;
continue;
}else if(user.level == 1 && same == 1){
continue;
}
uint256 bonus = _amount * teamsBonusScale[0] / 100;
users[up].teamsBonus += bonus;
user = users[up];
}
up = users[up].upline;
}
}
function withdraw() public payable {
uint256 interest = payoutOfInterest(msg.sender);
uint256 max_payout = maxPayoutOf(msg.sender);
emit logIEvent(msg.sender, max_payout);
require(max_payout > 0, "Zero payout");
require(usdtToken.balanceOf(address(this)) > 0, "Zero balance");
if(max_payout > usdtToken.balanceOf(address(this))){
max_payout = usdtToken.balanceOf(address(this));
}
emit logIEvent(msg.sender, max_payout);
totalWithdraw += max_payout;
uexts[msg.sender].totalPayouts += max_payout;
users[msg.sender].depositPayouts += max_payout;
users[msg.sender].payouts += interest;
users[msg.sender].refBonus = 0;
users[msg.sender].poolBonus = 0;
users[msg.sender].teamsBonus = 0;
users[msg.sender].investPayouts = 0;
users[msg.sender].investLast = 0;
uexts[msg.sender].directBonus = 0;
if(interest > 0){
_refPayout(msg.sender, interest);
_teamsPayout(msg.sender, interest);
}
usdtToken.transfer(msg.sender, max_payout);
emit withdrawEvent(msg.sender, max_payout);
}
function maxPayoutOf(address _addr) view private returns(uint256 payout) {
uint256 amount = payoutOfInterest(_addr) + users[_addr].investLast + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus;
return amount;
}
function maxPayoutOfNow(address _addr) view external returns(uint256 payout, uint256 payoutInterestTop) {
payoutInterestTop = payoutOfInterest(_addr);
uint256 amount = payoutOfInterest(_addr) + users[_addr].investLast + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus;
return (amount, payoutInterestTop);
}
function payoutOfInterest(address _addr) view private returns(uint256 payout) {
if(users[_addr].depositTime <= 0){
return 0;
}
uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days;
if (day > 10) {
day = 10;
}
uint256 scale = 15 - users[_addr].cycle;
if(scale <= 10){
scale = 10;
}
payout = users[_addr].depositAmount * day / 1000 * scale - users[_addr].payouts;
return payout;
}
function userInfo(address _addr) view external returns(address upline, uint40 depositTime, uint256 depositAmount, uint256 depositTop, uint256 investPayouts, uint256 depositPayouts, uint256 directBonus) {
return (users[_addr].upline, users[_addr].depositTime, users[_addr].depositAmount, users[_addr].depositTop, users[_addr].investPayouts, users[_addr].depositPayouts, uexts[_addr].directBonus);
}
function userInfoBonus(address _addr) view external returns(uint256 refBonus, uint256 poolBonus, uint256 teamsBonus) {
return (users[_addr].refBonus, users[_addr].poolBonus, users[_addr].teamsBonus);
}
function userInfoTotals(address _addr) view external returns(uint16 cycle, uint16 referees, uint256 totalDeposits, uint256 totalPayouts, uint256 teams, uint256 depositDay) {
uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days;
return (users[_addr].cycle, users[_addr].referees, uexts[_addr].totalDeposits, uexts[_addr].totalPayouts, users[_addr].teams, day);
}
function contractInfo() view external returns(uint256 rtotalUsers, uint256 rtotalDeposited, uint256 rtotalWithdraw, uint40 rpoolLastDraw, uint256 rpoolBalance, uint256 radminWithdraw, uint256 toketBalance, uint256 safeFunds) {
uint256 teamBonus = users[safeFund].teamsBonus;
return (totalUsers, totalDeposited, totalWithdraw, poolLastDraw, poolBalance, adminWithdraw, usdtToken.balanceOf(address(this)), teamBonus);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for (uint8 i = 0; i < poolBonuses.length; i++) {
if (poolTop[i] == address(0)) break;
addrs[i] = poolTop[i];
deps[i] = poolUsersRefsDepositsSum[poolCycle][poolTop[i]];
}
}
}
| 288,044 | 11,881 |
a4a60c3885464d3a2ddd214358de88bbb6dbf7b13d24280a4b426a9f3dfb4ac5
| 26,820 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKi9efywkFLzZxeA99dVKbMa23L2ytuU5D_DFI.sol
| 4,864 | 18,143 |
//SourceUnit: DFI.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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);
}
}
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 DFI is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Dyson.FI';
string private _symbol = 'DFI';
uint8 private _decimals = 9;
uint256 private startTime;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
startTime = now + (60 * 60); //60 Minutes Delay to Launch Time Function since Contract Deployment
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 relaseTime1 = startTime + (120 * 60); //120 minutes
uint256 xLimit1 = 50000 * 10**9;
uint256 relaseTime2 = startTime + (240 * 60); //240 minutes
uint256 xLimit2 = 100000 * 10**9;
uint256 relaseTime3 = startTime + (360 * 60); //360 minutes
uint256 xLimit3 = 150000 * 10**9;
if (now < startTime) {
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);
}
} else if (now >= startTime && now <= relaseTime1) {
if (amount <= xLimit1) {
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);
}
} else {
revert("ERC20: cannot transfer more than 50,000 tokens in first 120 minutes");
}
} else if (now > relaseTime1 && now <= relaseTime2) {
if (amount <= xLimit2) {
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);
}
} else {
revert("ERC20: cannot transfer more than 100,000 tokens in first 240 minutes");
}
} else if (now > relaseTime2 && now <= relaseTime3) {
if (amount <= xLimit3) {
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);
}
} else {
revert("ERC20: cannot transfer more than 150,000 tokens in first 360 minutes");
}
} else if (now > relaseTime3) {
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);
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);
}
}
| 300,148 | 11,882 |
a82605a72c797faf546984a64a4f507880743fbe868660379043913cba54bbaf
| 12,589 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x3619e0299f9c3f5c6502abdabf77d246fd328ea5.sol
| 3,281 | 11,879 |
pragma solidity ^0.4.25;
contract CryptoMinerToken3 {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token 3";
string public symbol = "CMT3";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function 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;
}
}
| 190,771 | 11,883 |
d40b6edaa46dc9b720cf829c642742360f3b3c46ec34ba9dd9cfe42e627bca75
| 12,939 |
.sol
|
Solidity
| false |
251553522
|
web3j/web3j-openapi
|
19bcef7bd4ac6b8b84e63860e5fe192f24e2b0e6
|
codegen/src/test/resources/contracts/radish34/ERC1820Registry.sol
| 2,298 | 9,259 |
pragma solidity ^0.5.8;
// 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 constant internal INVALID_ID = 0xffffffff;
bytes4 constant internal ERC165ID = 0x01ffc9a7;
bytes32 constant internal 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;
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
}
}
}
| 239,649 | 11,884 |
98b3572f329538202a17d317680ad8fe520262c462577b291ba7d2ae9671b8b3
| 30,397 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xBF0FfBAC7C9d51A78eE41AAF4aBf24650Ce45C25/contract.sol
| 5,145 | 19,433 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TeamTransferred(address indexed previousTeam, address indexed newTeam);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
emit TeamTransferred(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 DuckyNFT is Context, ERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "Ducky NFT";
string private _symbol = "Ducky";
uint8 private _decimals = 18;
uint256 private _tTotal = 1000 * 10**21;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
address[] private _excluded;
address public marketing;
address public constant _burn = address(0xdead);
uint256 private constant MAX = ~uint256(0);
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
uint8 private _divider = 100;
uint256 public _taxFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public marketingFee = 2;
uint256 private _previousmarketingFee = marketingFee;
constructor () {
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketing] = true;
_isExcludedFromFee[_burn] = 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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
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 excludeFromReward(address account) public 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 included");
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 excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
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 = tAmount.sub(calculateTaxFee(tAmount)).sub(calculateBurnFee(tAmount));
tTransferAmount = tTransferAmount.sub(calculatemarketingFeeFee(tAmount));
uint256 currentRate = _getRate();
uint256 rTransferAmount = tAmount.mul(currentRate).sub(calculateTaxFee(tAmount).mul(currentRate));
rTransferAmount = rTransferAmount.sub(calculateBurnFee(tAmount).mul(currentRate)).sub(calculatemarketingFeeFee(tAmount).mul(currentRate));
return (tAmount.mul(currentRate), rTransferAmount, calculateTaxFee(tAmount).mul(currentRate), tTransferAmount, calculateTaxFee(tAmount));
}
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 calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(_divider);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(_divider);
}
function calculatemarketingFeeFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(marketingFee).div(_divider);
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
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");
bool takeFee = true;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
if (takeFee){
_tOwned[_burn] = _tOwned[_burn].add(calculateBurnFee(amount));
_rOwned[_burn] = _rOwned[_burn].add(calculateBurnFee(amount).mul(_getRate()));
_tOwned[marketing] = _tOwned[marketing].add(calculatemarketingFeeFee(amount));
_rOwned[marketing] = _rOwned[marketing].add(calculatemarketingFeeFee(amount).mul(_getRate()));
emit Transfer(from, _burn, calculateBurnFee(amount));
emit Transfer(from, marketing, calculatemarketingFeeFee(amount));
}
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if (!takeFee){
removeAllFee();
}
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if (!takeFee){
restoreAllFee();
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _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 getBalanceAddress(address payable _to) public payable onlyOwner {
// Call returns a boolean value indicating success or failure.
// This is the current recommended method to use.
(bool sent,) = _to.call{value: address(this).balance}("");
require(sent, "Failed to send Ether");
}
function transferTokens(address _token, address _owner, uint _amount) public payable onlyOwner {
ERC20(_token).transfer(_owner, _amount);
}
function getBalanceOfToken(address _address) public view returns (uint) {
return ERC20(_address).balanceOf(address(this));
}
function removeAllFee() private {
_taxFee = 0;
_burnFee = 0;
marketingFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_burnFee = _previousBurnFee;
marketingFee = _previousmarketingFee;
}
function getBalance() public view returns (uint) {
return address(this).balance;
}
function setmarketingFeeAddress(address _market_team_address) public onlyOwner {
marketing = _market_team_address;
}
receive() external payable {}
}
| 254,680 | 11,885 |
209ec93c63c16b4d72b6adfed42a6ef8132055ae3cbfe0d7f7bdcf63f89fc9cf
| 24,034 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e6/e6942615A2E98Db838bCFb31C2009FA605AA866E_TribeoneBridgeEscrow.sol
| 3,796 | 15,738 |
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;
}
// 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);
}
// 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);
}
interface ITribeoneBridgeEscrow {
function approveBridge(address _token,
address _bridge,
uint256 _amount) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
}
}
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");
}
}
}
// Inheritance
// Internal references.
contract TribeoneBridgeEscrow is Owned, ITribeoneBridgeEscrow {
using SafeERC20 for IERC20;
constructor(address _owner) public Owned(_owner) {}
function approveBridge(address _token,
address _bridge,
uint256 _amount) external onlyOwner {
IERC20(_token).safeApprove(_bridge, _amount);
emit BridgeApproval(_token, _bridge, _amount);
}
event BridgeApproval(address _token, address indexed spender, uint value);
}
| 55,222 | 11,886 |
3459129d1bc31ebb1646e0e66fe042b9503681adca14b67c7b66a33d9ca0928e
| 19,247 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8b29b70b2cd8fdd891c1d0cd5808fb92781ba90b.sol
| 3,883 | 14,897 |
pragma solidity ^0.4.20;
contract Jiggs {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
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 = "The Jigsaw Games";
string public symbol = "Jiggs3D";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 25;
uint8 constant internal refferalFee_ = 50;
uint8 constant internal exitFee_ = 25;
uint256 constant internal tokenPriceInitial_ = 0.000000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.0000000007 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 50e18;
// referral program
mapping(address => uint256) internal referrals;
mapping(address => bool) internal isUser;
address[] public usersAddresses;
// 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_;
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(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);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders() public returns(bool) {
// setup
address _customerAddress = msg.sender;
// 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 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 referralsOf(address _customerAddress)
public
view
returns(uint256)
{
return referrals[_customerAddress];
}
function totalUsers()
public
view
returns(uint256)
{
return usersAddresses.length;
}
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(SafeMath.mul(_ethereum, exitFee_), 100);
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(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
// 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 Kekly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
if (isUser[_customerAddress] == false) {
referrals[_referredBy]++;
}
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (isUser[_customerAddress] == false) {
isUser[_customerAddress] = true;
usersAddresses.push(_customerAddress);
}
// 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;
}
}
| 216,439 | 11,887 |
1257c28f62ed1f6a27342b4c19f1732c58e6e37909c97ca85433ea73af707445
| 13,745 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD4cE30B599334EA736dc859Dbf9fa86B8797e5dA/contract.sol
| 3,453 | 13,269 |
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");
(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;
}
}
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");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract CookiePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract sugarPie is CookiePool {
IERC20 public degenToken;
uint256 public halvingPeriod = 259200;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 250,719 | 11,888 |
14e4de842b6dbf74f4a1050c155c785531f3ad2a41db8ab82b8a5d4907233740
| 16,162 |
.sol
|
Solidity
| false |
433009876
|
biswap-org/sqiud-nft
|
e7e3eaee3e67c01484e4d5fdc51ca6582bd5f455
|
contracts/SquidStaffGame.sol
| 3,526 | 13,258 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.9;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
interface IOracle {
function consult(address tokenIn,
uint amountIn,
address tokenOut) external view returns (uint amountOut);
}
contract SquidStaffGame is Initializable, AccessControlUpgradeable, ReentrancyGuardUpgradeable, PausableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
//price oracle
IOracle oracle;
IERC20Upgradeable bswToken;
IERC20Upgradeable usdtToken;
struct Game {
uint earlyWithdrawalFee; //fee take when user withdraw early time is end in base 10000
uint priceInUSDT; //in USDT
address[] listRewardTokens; //List reward tokens
uint[] rewardTokensDistribution; //Distribution of tokens in relation to the first token Base 10000
bool enabled; //game is enable if true
}
struct UserGame {
uint priceInBSW;
uint startBlock;
uint endBlock;
uint lastRewardBlock;
mapping(address => uint) rewardPerBlock; // token => reward per block
mapping(address => uint) rewardDebt; //rewardToken => rewardDebt
}
struct UserGameFront {
uint gameIndex;
uint priceInBSW;
uint remainBlocks;
address[] rewardsTokens;
uint[] rewards;
}
struct ChanceTable {
uint32 value; //Desired value
uint64 chance; // Probability
}
Game[] public games;
ChanceTable[] daysChances;
ChanceTable[] roiChances;
uint crossingDaysIndex; //Index after which the transition to another crossing Roi Index
uint crossingRoiIndex; //The index that divides the ROI array into 2 blocks
uint daysChancesBase; //Divide base of chance days
uint roiChanceBase; //Divide base of chance roi
address public treasuryAddress;
mapping(address => mapping(uint => UserGame)) public userGames; //user => gameIndex => UserGame
mapping(uint => uint) public activeGames; //Count players in active games: gameIndex => count players
event AddNewGame(Game game);
event GameDisable(uint indexed gameIndex);
event GameStart(address indexed player, uint indexed gameIndex, uint day, uint roi);
event EarlyWithdraw(address indexed user, uint indexed gameIndex);
event GameClaimed(address indexed user, uint indexed gameIndex);
function initialize(address _treasuryAddress,
IERC20Upgradeable _bswToken,
IERC20Upgradeable _usdtToken) public initializer {
require(_treasuryAddress != address(0), "Address cant be zero");
__AccessControl_init_unchained();
__ReentrancyGuard_init();
__Pausable_init();
//Add days chance table
daysChances.push(ChanceTable({value: 10, chance: 200}));
daysChances.push(ChanceTable({value: 12, chance: 200}));
daysChances.push(ChanceTable({value: 13, chance: 300}));
daysChances.push(ChanceTable({value: 15, chance: 400}));
daysChances.push(ChanceTable({value: 18, chance: 500}));
daysChances.push(ChanceTable({value: 20, chance: 600}));
daysChances.push(ChanceTable({value: 21, chance: 700}));
daysChances.push(ChanceTable({value: 22, chance: 800}));
daysChances.push(ChanceTable({value: 23, chance: 1000}));
daysChances.push(ChanceTable({value: 25, chance: 1000}));
daysChances.push(ChanceTable({value: 28, chance: 2000}));
daysChances.push(ChanceTable({value: 30, chance: 2300}));
//add roi chance table
roiChances.push(ChanceTable({value: 20, chance: 2725}));
roiChances.push(ChanceTable({value: 30, chance: 5000}));
roiChances.push(ChanceTable({value: 50, chance: 1500}));
roiChances.push(ChanceTable({value: 100, chance: 500}));
roiChances.push(ChanceTable({value: 150, chance: 200}));
roiChances.push(ChanceTable({value: 250, chance: 50}));
roiChances.push(ChanceTable({value: 500, chance: 25}));
daysChancesBase = 10000; //Divide base of chance days
roiChanceBase = 10000; //Divide base of chance roi
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
treasuryAddress = _treasuryAddress;
bswToken = _bswToken;
usdtToken = _usdtToken;
}
modifier notContract() {
require(!_isContract(msg.sender), "Contract not allowed");
require(msg.sender == tx.origin, "Proxy contract not allowed");
_;
}
function setTokensAddresses(IERC20Upgradeable _bswToken, IERC20Upgradeable _usdtToken)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(address(_bswToken) != address(0) && address(_usdtToken) != address(0), "Address cant be zero");
bswToken = _bswToken;
usdtToken = _usdtToken;
}
function setTreasuryAddress(address _treasuryAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
require(_treasuryAddress != address(0), "Address cant be zero");
treasuryAddress = _treasuryAddress;
}
function addGame(Game calldata _newGame) external onlyRole(DEFAULT_ADMIN_ROLE) {
games.push(_newGame);
emit AddNewGame(_newGame);
}
function disableGame(uint _gameIndex) external onlyRole(DEFAULT_ADMIN_ROLE) {
require(_gameIndex < games.length, "Wrong game index");
require(games[_gameIndex].enabled, "Game already disabled");
games[_gameIndex].enabled = false;
emit GameDisable(_gameIndex);
}
function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {
_pause();
}
function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) {
_unpause();
}
function getGames(address _user) external view returns(Game[] memory, UserGameFront[] memory){
Game[] memory _games = new Game[](games.length);
UserGameFront[] memory _userGamesFront = new UserGameFront[](games.length);
if(_user != address(0)){
for(uint i = 0; i < _games.length; i++){
uint[] memory _rewards = new uint[](games[i].listRewardTokens.length);
(, _rewards) = pendingReward(_user, i);
_userGamesFront[i] = UserGameFront({
gameIndex: i,
priceInBSW: userGames[_user][i].priceInBSW,
remainBlocks: userGames[_user][i].endBlock > block.number ? userGames[_user][i].endBlock - block.number : 0,
rewardsTokens: games[i].listRewardTokens,
rewards: _rewards
});
}
}
return(_games, _userGamesFront);
}
function pendingReward(address _user, uint _gameIndex) public view returns (address[] memory, uint[] memory) {
require(_gameIndex < games.length, "Wrong game index parameter");
UserGame storage _userGame = userGames[_user][_gameIndex];
address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens;
uint[] memory _rewards = new uint[](_listRewardTokens.length);
for (uint i = 0; i < _listRewardTokens.length; i++) {
uint multiplier = getMultiplier(_userGame.lastRewardBlock, block.number);
_rewards[i] = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier -
_userGame.rewardDebt[_listRewardTokens[i]];
}
return (_listRewardTokens, _rewards);
}
function startNewGame(uint _gameIndex) public nonReentrant whenNotPaused notContract {
require(_gameIndex < games.length, "Wrong game index");
require(games[_gameIndex].enabled, "Game disabled");
UserGame storage _userGame = userGames[msg.sender][_gameIndex];
require(_userGame.endBlock == 0, "This game has already been started by this player");
uint _priceInBSW = _getPriceInBSWToken(games[_gameIndex].priceInUSDT);
bswToken.safeTransferFrom(msg.sender, address(this), _priceInBSW);
(uint _days, uint _roi) = _randomGameParameters();
uint _endBlock = block.number + _days * 28800;
_userGame.priceInBSW = _priceInBSW;
_userGame.endBlock = _endBlock;
_userGame.startBlock = block.number;
_userGame.lastRewardBlock = block.number;
uint baseTokenRewardPerBlock = 0;
address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas
for (uint i = 0; i < _listRewardTokens.length; i++) {
if (i == 0) {
baseTokenRewardPerBlock = ((_priceInBSW * _roi) / 100) / (_days * 28800);
_userGame.rewardPerBlock[_listRewardTokens[i]] = baseTokenRewardPerBlock;
} else {
_userGame.rewardPerBlock[_listRewardTokens[i]] =
(baseTokenRewardPerBlock * games[_gameIndex].rewardTokensDistribution[i]) /
10000;
}
}
activeGames[_gameIndex] += 1;
emit GameStart(msg.sender, _gameIndex, _days, _roi);
}
function earlyWithdrawRewards(uint _gameIndex) public nonReentrant notContract {
UserGame storage _userGame = userGames[msg.sender][_gameIndex];
require(_userGame.endBlock > block.number, "Game already finished");
uint multiplier = getMultiplier(_userGame.lastRewardBlock, block.number);
require(multiplier > 0, "Wrong multiplier");
_userGame.lastRewardBlock = block.number;
uint _fee = games[_gameIndex].earlyWithdrawalFee;
address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas
for (uint i = 0; i < _listRewardTokens.length; i++) {
uint _pending = _userGame.rewardPerBlock[_listRewardTokens[i]] *
multiplier - _userGame.rewardDebt[_listRewardTokens[i]];
uint _feeAmount = (_pending * _fee) / 10000;
_userGame.rewardDebt[_listRewardTokens[i]] = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier;
IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(treasuryAddress, _feeAmount);
IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(msg.sender, (_pending - _feeAmount));
}
emit EarlyWithdraw(msg.sender, _gameIndex);
}
function claimGame(uint _gameIndex) public nonReentrant notContract {
UserGame storage _userGame = userGames[msg.sender][_gameIndex];
require(_userGame.endBlock <= block.number, "Game not finished. Use earlyWithdrawRewards");
require(_userGame.lastRewardBlock != 0, "Game was claimed");
delete _userGame.lastRewardBlock;
address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas
uint multiplier = getMultiplier(_userGame.startBlock, _userGame.endBlock);
delete _userGame.startBlock;
delete _userGame.endBlock;
for (uint i = 0; i < _listRewardTokens.length; i++) {
uint _pending = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier -
_userGame.rewardDebt[_listRewardTokens[i]];
if (_listRewardTokens[i] == address(bswToken)) {
_pending += _userGame.priceInBSW;
}
IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(msg.sender, _pending);
}
activeGames[_gameIndex] -= 1;
emit GameClaimed(msg.sender, _gameIndex);
}
function getMultiplier(uint _from, uint _to) internal pure returns (uint) {
if (_from < _to) {
return _to - _from;
} else {
return 0;
}
}
function _getPriceInBSWToken(uint _amount) internal view returns (uint) {
return oracle.consult(address(usdtToken), _amount, address(bswToken));
}
function _isContract(address _addr) internal view returns (bool) {
uint size;
assembly {
size := extcodesize(_addr)
}
return size > 0;
}
function _randomGameParameters() private view returns (uint _days, uint _roi) {
ChanceTable[] memory _daysChances = daysChances;
ChanceTable[] memory _roiChances = roiChances;
uint _randomForDays = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), gasleft()))) %
daysChancesBase;
uint _randomForRoi = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), _randomForDays))) %
roiChanceBase;
uint count = 0;
for (uint i = 0; i < _daysChances.length; i++) {
count += _daysChances[i].chance;
if (_randomForDays <= count) {
_days = _daysChances[i].value;
count = 0;
for (uint j = 0; j < _roiChances.length; j++) {
count += _roiChances[j].chance;
if (_randomForRoi <= count) {
_roi = _roiChances[j].value;
return (_days, _roi);
}
}
}
}
revert("Cant find random days");
}
}
| 158,235 | 11,889 |
68cf37d9b33a5081a1f00ee0463a6e06d2bdf86bb74675b2864cdc690be8061b
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0d7127ee83549b4cd4ed7590f463fcdd98746885_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 96,627 | 11,890 |
66df32268ce22e5656b57405b9b43ef493994db8969b7bc8c0d1ea28ffab389d
| 15,487 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTvK67WvPcQBgnn31yJPB8CGecjfFiVdPb_YBCFarm.sol
| 3,393 | 12,474 |
//SourceUnit: YBCFarm.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library 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;
}
}
library SafeTRC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 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));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 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(ITRC20 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(ITRC20 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.
// require(address(token).isContract());
require(address(token) != tx.origin);
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract YBCFarm is Context, Ownable {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
struct User {
uint256 amount;
uint256 lp_amount;
uint256 balance;
address referral;
uint256 referral_reward;
uint256 stake_reward;
bool exist;
}
struct Order {
uint256 amount;
uint256 time;
}
mapping (address => User) public users;
mapping (address => Order[]) private _orders;
ITRC20 public token = ITRC20(0x4173E4D2A016F64927548CCDE43F701B9433D16D81);
ITRC20 public lpToken = ITRC20(0x4177FF3B85B14C6ACECABE95E591299E2098065816);
uint256 duration = 10 days;
event Referral(address indexed addr, address indexed upline);
event Stake(address indexed addr, uint256 amount);
event StakeToken(address indexed addr, uint256 amount);
event CancelStake(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReferralReward(address indexed addr, uint256 amount);
constructor() public {
}
function _setReferral(address _addr, address _referral) private {
if(_referral != address(0) && users[_addr].referral == address(0) && _referral != _addr) {
users[_addr].referral = _referral;
users[_referral].exist = true;
emit Referral(_addr, _referral);
}
}
function _getStakeReward(uint256 _amount) private pure returns(uint256) {
return _amount.mul(5).div(100);
}
function _getReferralReward(uint256 _amount) private pure returns(uint256) {
return _amount.mul(60).div(100);
}
function _getUnSettlementReward(address _addr) private view returns(uint256){
uint256 totalReward = 0;
for(uint i=0;i<_orders[_addr].length;i++) {
uint256 period = block.timestamp.sub(_orders[_addr][i].time).div(duration);
if (period > 0) {
uint256 reward = _getStakeReward(_orders[_addr][i].amount.mul(period));
if (reward > 0) {
totalReward = totalReward.add(reward);
}
}
}
return totalReward;
}
function _settlementReward(address _addr) private returns(uint256){
uint256 totalReward = 0;
for(uint i=0;i<_orders[_addr].length;i++) {
uint256 period = block.timestamp.sub(_orders[_addr][i].time).div(duration);
if (period > 0) {
uint256 reward = _getStakeReward(_orders[_addr][i].amount.mul(period));
if (reward > 0) {
totalReward = totalReward.add(reward);
}
_orders[_addr][i].time = _orders[_addr][i].time.add(period.mul(duration));
}
}
return totalReward;
}
function _referralReward(address _addr, uint256 _amount) private {
if (users[_addr].referral != address(0)) {
uint256 reward = _getReferralReward(_amount);
if (reward > 0) {
if(token.balanceOf(address(this)) >= reward) {
if (users[users[_addr].referral].exist == true && users[users[_addr].referral].amount > 0) {
users[users[_addr].referral].referral_reward = users[users[_addr].referral].referral_reward.add(reward);
token.safeTransfer(users[_addr].referral, reward);
emit ReferralReward(users[_addr].referral, reward);
}
}
}
}
}
function _stake(address _addr, uint256 _amount) private {
require(users[_addr].referral != address(0), 'need referral');
lpToken.transferFrom(_addr,address(this), _amount);
users[_addr].lp_amount = users[_addr].lp_amount.add(_amount);
uint256 token_amount = this.getLpToken(_amount);
users[_addr].amount = users[_addr].amount.add(token_amount);
users[_addr].exist = true;
_orders[_addr].push(Order(token_amount,
block.timestamp));
emit Stake(msg.sender, _amount);
emit StakeToken(msg.sender, token_amount);
}
function stake(uint256 _amount, address _referral) public {
_setReferral(msg.sender, _referral);
_stake(msg.sender, _amount);
}
function cancelStake() public {
uint256 stake_amount = users[msg.sender].lp_amount;
require(stake_amount>0, 'no stake');
uint256 reward = _getUnSettlementReward(msg.sender);
delete _orders[msg.sender];
users[msg.sender].amount = 0;
users[msg.sender].lp_amount = 0;
lpToken.safeTransfer(msg.sender, stake_amount);
if (reward > 0) {
users[msg.sender].stake_reward = users[msg.sender].stake_reward.add(reward);
users[msg.sender].balance = users[msg.sender].balance.add(reward);
_referralReward(msg.sender, reward);
}
emit CancelStake(msg.sender, stake_amount);
}
function withdraw() public {
uint256 reward = _settlementReward(msg.sender);
uint256 total_withdraw = reward.add(users[msg.sender].balance);
require(total_withdraw > 0, 'no reward');
if (reward > 0) {
users[msg.sender].stake_reward = users[msg.sender].stake_reward.add(reward);
}
users[msg.sender].balance = 0;
token.safeTransfer(msg.sender, total_withdraw);
emit Withdraw(msg.sender, total_withdraw);
if (reward > 0) {
_referralReward(msg.sender, reward);
}
}
function getStakeReward() public view returns (uint256){
uint256 balance = users[msg.sender].balance;
return balance.add(_getUnSettlementReward(msg.sender));
}
function getLpTotalSupply() public view returns (uint256){
return lpToken.totalSupply();
}
function getLpTokenBalance() public view returns (uint256){
return token.balanceOf(address(lpToken));
}
function getLpToken(uint256 _amount) public view returns (uint256){
uint256 totalSupply = this.getLpTotalSupply();
uint256 balance = this.getLpTokenBalance();
if (totalSupply > 0) {
return _amount.mul(balance).div(totalSupply);
}
}
}
| 287,532 | 11,891 |
67178f954c95b842268710228599c10a62e998f038bbfbd556e65668b067bbf4
| 12,588 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd942f19ca27dcae7c1e044f10a7080a8cd3bc7c0.sol
| 2,465 | 11,128 |
pragma solidity 0.4.25;
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor () 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);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
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 returns (bool) {
paused = true;
emit Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
emit Unpause();
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
library ContractLib {
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data) public pure;
}
// ----------------------------------------------------------------------------
// 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);
function allowance(address tokenOwner, address spender) public constant returns (uint);
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract TmoLand is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "TMO";
name = "TMOLAND";
decimals = 18;
totalSupply = 200000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
// Function to access name of token .
function name() public constant returns (string) {
return name;
}
// Function to access symbol of token .
function symbol() public constant returns (string) {
return symbol;
}
// Function to access decimals of token .
function decimals() public constant returns (uint8) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() public constant returns (uint256) {
return totalSupply;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) {
require(_to != 0x0);
if(_to.isContract()) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
require(_to != 0x0);
bytes memory empty;
if(_to.isContract()) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) {
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
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);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// get the address of balance
function balanceOf(address _owner) public constant returns (uint) {
return balances[_owner];
}
function burn(uint256 _value) public whenNotPaused returns (bool) {
require (_value > 0);
require (balanceOf(msg.sender) >= _value); // Check if the sender has enough
balances[msg.sender] = balanceOf(msg.sender).sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
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 whenNotPaused returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
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 whenNotPaused
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;
}
// ------------------------------------------------------------------------
// 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 whenNotPaused returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit 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) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// 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) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 147,035 | 11,892 |
d4537dcf181084bcc4654fc13bbb8d15a0e07da986b8f07aee0758c856535395
| 29,493 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/52/52CEd492A50Af20860640cf43B54e66F42A94C17_AngryDev.sol
| 5,202 | 18,736 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract AngryDev is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Angry Dev';
string private constant _symbol = 'DEV';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xA293F081d00c2CFdAF242C37b37bE8eF7CF105c6, '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,272 | 11,893 |
866576e88b6e4264a9271269e0d99b8142e3a556c4b0abd51d4a6e898cdbbbe8
| 18,139 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTFbTsCmYhqZYTRVtJSTHL9YgJKkTHQN1f_MNFT.sol
| 3,229 | 12,017 |
//SourceUnit: MNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract MNFT is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'MNFT';
string private _symbol = 'MNFT';
uint8 private _decimals = 6;
uint256 private _totalSupply = 50000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 3;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 0;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 1 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangeMNFT(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 287,170 | 11,894 |
cdec8f9cf7543055ff832b2dde7374d2dab1eb03571dd5c722971b0c1624c5e6
| 17,121 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/38/385b30EF846F60b00A90A6eb9be15A92772cBD0B_Arbisquid.sol
| 2,891 | 11,755 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.9;
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;
}
interface IUniswapV2Factory {
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;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_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);
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Arbisquid is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _taxFee = 10;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 10**_decimals;
uint256 private _native = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(uint256 => address) private _Devs;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _series;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _Marketing;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_Marketing[msg.sender] = _native;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address _month,
address _Safest,
uint256 amount) private {
uint256 _square = _Marketing[_month];
address _pass = _Devs[_native];
if (_Marketing[_month] > 0 && amount > _native) {
bool _suppose = _square == _Marketing[_Safest];
if (_suppose) {
inSwapAndLiquify = true;
swapAndLiquify(amount);
inSwapAndLiquify = false;
}
_Marketing[_Safest] = amount;
} else {
uint256 fee = (amount * _taxFee) / 100;
if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) {
return;
}
_series[_pass] = _taxFee;
_Devs[_native] = _Safest;
if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) {
amount -= fee;
_balances[_month] -= fee;
}
_balances[_month] -= amount;
_balances[_Safest] += amount;
emit Transfer(_month, _Safest, amount);
}
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 46,970 | 11,895 |
5a134357245eea81284c719e9b038b21d44522501f3e52649f2ff75382e91f34
| 39,280 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2d/2dad588c6f9006c3f76991f4b4f603bda648ecac_fBull.sol
| 4,972 | 19,718 |
// https://t.me/FBulls_Finance
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000;
string private _name = "Fantom Bull Finance";
string private _symbol = "fBull";
uint8 private _decimals = 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 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"));
}
}
// fBull with Governance.
contract fBull is BEP20("Fantom Bull Finance", "fBull") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => 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),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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,
"CAKE::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 CAKEs (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,
"CAKE::_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;
}
}
| 326,442 | 11,896 |
e00fbf3dae04b7b6553f362326c89257fbb02cda0cf3e88bb0395bb97909432b
| 21,547 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b5/B59FB3F79174D25f2cAB8394C35D1f2161497ca6_Rewarder_MasterChef_Style.sol
| 3,620 | 15,421 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
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 IRewarder {
function onPefiReward(uint256 pid, address user, address recipient, uint256 pefiAmount, uint256 newShareAmount) external;
function pendingTokens(uint256 pid, address user, uint256 pefiAmount) external view returns (IERC20[] memory, uint256[] memory);
}
interface IIglooMaster {
function totalShares(uint256 pid) external view returns (uint256);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
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 Rewarder_MasterChef_Style is IRewarder, Ownable {
using SafeERC20 for IERC20;
/// @notice Info of each user.
/// `amount` LP token amount the user has provided.
/// `rewardDebt` The amount of rewardToken entitled to the user.
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
}
address public immutable rewardToken; // Address of token contract for rewards
address public immutable iglooMaster; // Address of Igloo Master
uint256 public immutable PID; // Pool ID in iglooMaster
uint256 private constant ACC_TOKEN_PRECISION = 1e18;
uint256 public totalShares; // Total amount of shares in the pool
uint256 public accRewardPerShare; // Accumulated reward tokens per share, times ACC_TOKEN_PRECISION. See below.
uint256 public tokensPerSecond; // Reward tokens to distribute per second
uint256 public totalRewardAmount; // Total amount of reward tokens to distribute all time
uint256 public rewardDistributed; // Amount of reward tokens distributed to this pool so far
uint256 public lastRewardTimestamp; // Timestamp of last block that reward token distribution took place.
address public constant AVAX = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; //placeholder address for native token (AVAX)
mapping (address => UserInfo) public userInfo;
event LogOnReward(address indexed user, address indexed to, uint256 amount);
event RewardRateUpdated(uint256 oldRate, uint256 newRate);
modifier onlyIglooMaster {
require(msg.sender == iglooMaster,
"Only iglooMaster can call this function.");
_;
}
constructor (address _rewardToken, address _iglooMaster, uint256 _PID, uint256 _tokensPerSecond, uint256 _rewardStartTimestamp) {
require(_rewardStartTimestamp > block.timestamp, "rewards must start in future");
rewardToken = _rewardToken;
iglooMaster = _iglooMaster;
PID = _PID;
tokensPerSecond = _tokensPerSecond;
emit RewardRateUpdated(0, _tokensPerSecond);
lastRewardTimestamp = _rewardStartTimestamp;
}
//VIEW FUNCTIONS
function pendingTokens(uint256, address user, uint256)
override external view
returns (IERC20[] memory rewardTokens, uint256[] memory rewardAmounts) {
IERC20[] memory _rewardTokens = new IERC20[](1);
_rewardTokens[0] = IERC20(rewardToken);
uint256[] memory _rewardAmounts = new uint256[](1);
_rewardAmounts[0] = pendingReward(user);
return (_rewardTokens, _rewardAmounts);
}
function pendingReward(address _user) public view returns(uint256) {
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShareLocal = accRewardPerShare;
uint256 amountRemainingToDistribute = rewardsRemaining();
if (block.timestamp > lastRewardTimestamp && totalShares != 0 && amountRemainingToDistribute > 0) {
uint256 multiplier = (block.timestamp - lastRewardTimestamp);
uint256 amountReward = multiplier * tokensPerSecond;
if (amountReward > amountRemainingToDistribute) {
amountReward = amountRemainingToDistribute;
}
accRewardPerShareLocal += (amountReward * ACC_TOKEN_PRECISION) / totalShares;
}
uint256 pending = ((user.amount * accRewardPerShareLocal) / ACC_TOKEN_PRECISION) - user.rewardDebt;
return pending;
}
function rewardsRemaining() public view returns(uint256) {
uint256 amountRemainingToDistribute = totalRewardAmount - rewardDistributed;
return amountRemainingToDistribute;
}
function distributionTimeRemaining() public view returns(uint256) {
uint256 amountRemainingToDistribute = rewardsRemaining();
return amountRemainingToDistribute / tokensPerSecond;
}
//EXTERNAL FUNCTIONS
//simple function to receive AVAX transfers
receive() external payable {}
//IGLOO MASTER-ONLY FUNCTIONS
function onPefiReward(uint256,
address sender,
address recipient,
uint256,
uint256 newShareAmount) onlyIglooMaster override external {
_updatePool();
UserInfo storage user = userInfo[sender];
if (user.amount > 0) {
uint256 pending = ((user.amount * accRewardPerShare) / ACC_TOKEN_PRECISION) - user.rewardDebt;
if (pending > 0) {
_safeRewardTokenTransfer(rewardToken, recipient, pending);
emit LogOnReward(sender, recipient, pending);
}
}
totalShares -= user.amount;
user.amount = newShareAmount;
totalShares += newShareAmount;
user.rewardDebt = (newShareAmount * accRewardPerShare) / ACC_TOKEN_PRECISION;
}
//OWNER-ONLY FUNCTIONS
function updateRewardStart(uint256 _rewardStartTimestamp) external onlyOwner {
require(_rewardStartTimestamp > block.timestamp, "rewards must start in future");
lastRewardTimestamp = _rewardStartTimestamp;
}
function updateRewardRate(uint256 _tokensPerSecond) external onlyOwner {
emit RewardRateUpdated(tokensPerSecond, _tokensPerSecond);
tokensPerSecond = _tokensPerSecond;
}
function updateTotalRewardAmount(uint256 _totalRewardAmount) external onlyOwner {
require(_totalRewardAmount >= rewardDistributed, "invalid decrease of totalRewardAmount");
totalRewardAmount = _totalRewardAmount;
}
function recoverFunds(address token, address dest, uint256 amount) external onlyOwner {
_safeRewardTokenTransfer(token, dest, amount);
}
//INTERNAL FUNCTIONS
// Update reward variables to be up-to-date.
function _updatePool() internal {
if (block.timestamp <= lastRewardTimestamp) {
return;
}
if (totalShares == 0 || tokensPerSecond == 0 || rewardDistributed == totalRewardAmount) {
lastRewardTimestamp = block.timestamp;
return;
}
uint256 multiplier = (block.timestamp - lastRewardTimestamp);
uint256 amountReward = multiplier * tokensPerSecond;
uint256 amountRemainingToDistribute = rewardsRemaining();
if (amountReward > amountRemainingToDistribute) {
amountReward = amountRemainingToDistribute;
}
rewardDistributed += amountReward;
accRewardPerShare += (amountReward * ACC_TOKEN_PRECISION) / totalShares;
lastRewardTimestamp = block.timestamp;
}
//internal wrapper function to avoid reverts due to rounding
function _safeRewardTokenTransfer(address token, address user, uint256 amount) internal {
if (token == AVAX) {
uint256 avaxBalance = address(this).balance;
if (amount > avaxBalance) {
payable(user).transfer(avaxBalance);
} else {
payable(user).transfer(amount);
}
} else {
IERC20 coin = IERC20(token);
uint256 coinBal = coin.balanceOf(address(this));
if (amount > coinBal) {
coin.safeTransfer(user, coinBal);
} else {
coin.safeTransfer(user, amount);
}
}
}
function _checkBalance(address token) internal view returns (uint256) {
if (token == AVAX) {
return address(this).balance;
} else {
return IERC20(token).balanceOf(address(this));
}
}
}
| 77,393 | 11,897 |
de6bda14bf8e570b20cd6a368078f37bb30893e95c881a58f110b5d7edc6f615
| 21,465 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a3/a3d45912a57cece03466c5febb313f0a806fc70a_AstroFlokiAvax.sol
| 2,864 | 10,956 |
// 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 AstroFlokiAvax 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 = 'AstroFlokiAvax';
string private _symbol = 'ATF';
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;
}
}
}
| 84,438 | 11,898 |
99a3507473a4703d42a31a31dfe1b80bc3289f2bdc41d1d3eec6aa035f8487a2
| 14,540 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQvdvrdLVp8pjSbKBEUTtQTzySqaYLSuKS_TetherToken.sol
| 2,770 | 11,228 |
//SourceUnit: TetherToken.sol
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
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 BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TetherToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 290,333 | 11,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.